@ooneex/gamification 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ooneex
+
+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

@@ -0,0 +1 @@
+# @ooneex/gamification

package/dist/flashcard/index.d.ts

@@ -0,0 +1,683 @@
+import { IImage } from "@ooneex/image";
+import { IStatus } from "@ooneex/status";
+import { ITag } from "@ooneex/tag";
+import { IBase as IBase2, IStat } from "@ooneex/types";
+import { IBase } from "@ooneex/types";
+interface ILevel extends IBase {
+	name: string;
+	code: string;
+	color: string;
+}
+declare enum ESessionType {
+	/** Learning-focused session with detailed explanations and guided experience */
+	TRAINING = "training",
+	/** Reinforcement session for solidifying already learned knowledge */
+	PRACTICE = "practice",
+	/** Mock test environment simulating real exam conditions */
+	SIMULATION = "simulation",
+	/** Quick knowledge check with immediate feedback */
+	QUIZ = "quiz",
+	/** Competitive or difficult questions designed to test limits */
+	CHALLENGE = "challenge",
+	/** Multiplayer competitive session with rankings and prizes */
+	TOURNAMENT = "tournament",
+	/** Session for revisiting previously answered questions and mistakes */
+	REVIEW = "review",
+	/** Initial assessment to identify knowledge gaps and skill levels */
+	DIAGNOSTIC = "diagnostic",
+	/** Time-pressured rapid-fire questions focusing on speed and accuracy */
+	SPEED_TEST = "speed_test"
+}
+declare enum EFlashcardState {
+	/** Brand new card that hasn't been studied yet */
+	NEW = "new",
+	/** Card in learning phase with short intervals */
+	LEARNING = "learning",
+	/** Card in relearning phase after being forgotten */
+	RELEARNING = "relearning",
+	/** Graduated card in long-term review cycle */
+	REVIEW = "review",
+	/** Card temporarily hidden until next day */
+	BURIED = "buried",
+	/** Card permanently hidden from reviews */
+	SUSPENDED = "suspended"
+}
+declare enum EFlashcardRating {
+	/** Incorrect answer - restart learning */
+	AGAIN = "again",
+	/** Correct but difficult - shorter interval */
+	HARD = "hard",
+	/** Correct with some effort - normal interval */
+	GOOD = "good",
+	/** Correct with no effort - longer interval */
+	EASY = "easy"
+}
+declare enum EFlashcardSessionStatus {
+	DRAFT = "draft",
+	STARTED = "started",
+	PAUSED = "paused",
+	COMPLETED = "completed"
+}
+declare enum EFlashcardAlgorithm {
+	/** Legacy SuperMemo 2 algorithm */
+	SM2 = "sm2",
+	/** Free Spaced Repetition Scheduler (modern) */
+	FSRS = "fsrs"
+}
+interface IFlashcardSchedule extends IBase2 {
+	/** Current state of the card */
+	state: EFlashcardState;
+	/** Days until next review */
+	interval: number;
+	/** Ease factor for SM-2 algorithm (2.5 = 250%) */
+	easeFactor: number;
+	/** Number of times card has been reviewed */
+	reviewCount: number;
+	/** Number of times card has failed (lapses) */
+	lapseCount: number;
+	/** Current step in learning/relearning sequence */
+	currentStep: number;
+	/** When the card is due for review */
+	dueDate: Date;
+	/** Last time the card was reviewed */
+	lastReviewedAt?: Date | null;
+	/** FSRS-specific parameters */
+	difficulty?: number;
+	stability?: number;
+	retrievability?: number;
+	/** Learning steps for this card (in minutes) */
+	learningSteps: number[];
+	/** Relearning steps for this card (in minutes) */
+	relearningSteps: number[];
+}
+interface IFlashcard extends IBase2 {
+	/** Front side content */
+	front: string;
+	/** Back side content */
+	back: string;
+	/** Optional hint text */
+	hint?: string;
+	/** Optional context or source */
+	context?: string;
+	contextId?: string;
+	/** Scheduling information */
+	schedule: IFlashcardSchedule;
+	/** Additional metadata */
+	tags?: ITag[];
+	stat?: IStat;
+	status?: IStatus;
+	image?: IImage;
+}
+interface IFlashcardReview extends IBase2 {
+	/** The flashcard being reviewed */
+	card: IFlashcard;
+	/** Session this review belongs to */
+	session: IFlashcardSession;
+	/** User's rating for this review */
+	rating: EFlashcardRating;
+	/** Time taken to answer (in seconds) */
+	responseTime: number;
+	/** Previous interval before this review */
+	previousInterval: number;
+	/** New interval after this review */
+	newInterval: number;
+	/** Previous ease factor */
+	previousEaseFactor: number;
+	/** New ease factor */
+	newEaseFactor: number;
+	/** Previous due date */
+	previousDueDate: Date;
+	/** New due date */
+	newDueDate: Date;
+	/** Previous card state */
+	previousState: EFlashcardState;
+	/** New card state */
+	newState: EFlashcardState;
+	/** Whether this was a lapse (forgotten card) */
+	wasLapse: boolean;
+	/** Algorithm used for scheduling */
+	algorithm: EFlashcardAlgorithm;
+	/** Review timestamp */
+	reviewedAt: Date;
+}
+interface IFlashcardSession extends IBase2 {
+	name: string;
+	/** Total cards available for study */
+	totalCards: number;
+	/** Number of new cards in session */
+	newCardsCount: number;
+	/** Number of learning cards in session */
+	learningCardsCount: number;
+	/** Number of review cards in session */
+	reviewCardsCount: number;
+	/** Cards studied so far */
+	studiedCount: number;
+	/** Cards answered correctly */
+	correctCount: number;
+	/** Cards answered incorrectly */
+	incorrectCount: number;
+	/** Total study time in seconds */
+	studyTime: number;
+	/** Cards in this session */
+	cards: IFlashcard[];
+	/** Reviews completed in this session */
+	reviews: IFlashcardReview[];
+	/** Session status */
+	status: EFlashcardSessionStatus;
+	/** Overall session score (0-100) */
+	score: number;
+	/** Session start time */
+	startedAt?: Date | null;
+	/** Session pause time */
+	pausedAt?: Date | null;
+	/** Session resume time */
+	resumedAt?: Date | null;
+	/** Session completion time */
+	completedAt?: Date | null;
+	/** Type of study session */
+	type: ESessionType;
+	/** Difficulty level */
+	level: ILevel;
+	/** Algorithm configuration */
+	algorithm: EFlashcardAlgorithm;
+	/** Maximum new cards per session */
+	maxNewCards: number;
+	/** Maximum review cards per session */
+	maxReviewCards: number;
+	/** Desired retention rate (0-1) for FSRS */
+	desiredRetention: number;
+	/** Learning steps (in minutes) */
+	learningSteps: number[];
+	/** Graduating interval (in days) */
+	graduatingInterval: number;
+	/** Easy interval (in days) */
+	easyInterval: number;
+	/** Maximum interval (in days) */
+	maxInterval: number;
+}
+interface IFlashcardDeck extends IBase2 {
+	name: string;
+	description?: string;
+	/** Total cards in deck */
+	totalCards: number;
+	/** New cards ready to learn */
+	newCards: number;
+	/** Cards in learning phase */
+	learningCards: number;
+	/** Cards due for review today */
+	dueCards: number;
+	/** Cards suspended */
+	suspendedCards: number;
+	/** All flashcards in this deck */
+	cards: IFlashcard[];
+	/** Deck settings */
+	algorithm: EFlashcardAlgorithm;
+	maxNewCardsPerDay: number;
+	maxReviewCardsPerDay: number;
+	desiredRetention: number;
+	learningSteps: number[];
+	relearningSteps: number[];
+	graduatingInterval: number;
+	easyInterval: number;
+	maxInterval: number;
+	/** FSRS parameters (17 parameters) */
+	fsrsParameters?: number[];
+	/** Leech threshold (number of lapses before marking as leech) */
+	leechThreshold: number;
+	/** Whether to bury sibling cards */
+	burySiblings: boolean;
+	/** Deck statistics */
+	stat?: IStat;
+	status?: IStatus;
+}
+interface IFlashcardPreset extends IBase2 {
+	name: string;
+	description?: string;
+	/** Algorithm to use */
+	algorithm: EFlashcardAlgorithm;
+	/** Learning configuration */
+	learningSteps: number[];
+	relearningSteps: number[];
+	graduatingInterval: number;
+	easyInterval: number;
+	maxInterval: number;
+	/** Daily limits */
+	maxNewCardsPerDay: number;
+	maxReviewCardsPerDay: number;
+	/** FSRS configuration */
+	desiredRetention: number;
+	fsrsParameters?: number[];
+	/** SM-2 configuration */
+	startingEaseFactor: number;
+	easyBonus: number;
+	intervalModifier: number;
+	hardInterval: number;
+	newInterval: number;
+	/** Lapse configuration */
+	minimumInterval: number;
+	leechThreshold: number;
+	/** Display options */
+	burySiblings: boolean;
+	showTimer: boolean;
+	autoPlayAudio: boolean;
+}
+interface IFlashcardStats extends IBase2 {
+	/** Cards studied today */
+	cardsStudiedToday: number;
+	/** Time spent studying today (minutes) */
+	timeSpentToday: number;
+	/** Current streak (days) */
+	currentStreak: number;
+	/** Longest streak (days) */
+	longestStreak: number;
+	/** Total reviews all time */
+	totalReviews: number;
+	/** Total study time all time (minutes) */
+	totalStudyTime: number;
+	/** Average retention rate */
+	retentionRate: number;
+	/** Breakdown by card state */
+	newCardsCount: number;
+	learningCardsCount: number;
+	reviewCardsCount: number;
+	suspendedCardsCount: number;
+	/** Maturity statistics */
+	matureCardsCount: number;
+	youngCardsCount: number;
+	/** Performance by rating */
+	againCount: number;
+	hardCount: number;
+	goodCount: number;
+	easyCount: number;
+	/** Date range for these stats */
+	startDate: Date;
+	endDate: Date;
+}
+/**
+* Base interface for spaced repetition algorithms
+*/
+interface ISpacedRepetitionAlgorithm {
+	/**
+	* Calculate the next review schedule for a card
+	*/
+	calculateNextReview: (card: IFlashcard, rating: EFlashcardRating, reviewTime: number) => IFlashcardSchedule;
+	/**
+	* Get the predicted intervals for each rating button
+	*/
+	getIntervalPreview: (card: IFlashcard) => Record<EFlashcardRating, number>;
+	/**
+	* Initialize a new card's schedule
+	*/
+	initializeCard: (learningSteps: number[]) => IFlashcardSchedule;
+	/**
+	* Get algorithm-specific parameters
+	*/
+	getParameters: () => Record<string, unknown>;
+	/**
+	* Update algorithm parameters
+	*/
+	setParameters: (parameters: Record<string, unknown>) => void;
+}
+/**
+* SM-2 (SuperMemo 2) Algorithm Implementation Interface
+*/
+interface ISM2Algorithm extends ISpacedRepetitionAlgorithm {
+	/**
+	* SM-2 specific parameters
+	*/
+	getParameters: () => {
+		startingEaseFactor: number;
+		easyBonus: number;
+		intervalModifier: number;
+		hardInterval: number;
+		newInterval: number;
+		minimumInterval: number;
+		maxInterval: number;
+		graduatingInterval: number;
+		easyInterval: number;
+	};
+	/**
+	* Calculate ease factor adjustment
+	*/
+	calculateEaseAdjustment: (rating: EFlashcardRating, currentEase: number) => number;
+	/**
+	* Calculate interval for review cards
+	*/
+	calculateReviewInterval: (previousInterval: number, easeFactor: number, rating: EFlashcardRating) => number;
+	/**
+	* Handle learning phase transitions
+	*/
+	processLearningCard: (card: IFlashcard, rating: EFlashcardRating, learningSteps: number[]) => {
+		newState: EFlashcardState;
+		interval: number;
+		currentStep: number;
+	};
+	/**
+	* Handle lapse (forgotten card)
+	*/
+	processLapse: (card: IFlashcard, relearningSteps: number[]) => {
+		newState: EFlashcardState;
+		interval: number;
+		easeFactor: number;
+		currentStep: number;
+	};
+}
+/**
+* FSRS (Free Spaced Repetition Scheduler) Algorithm Interface
+*/
+interface IFSRSAlgorithm extends ISpacedRepetitionAlgorithm {
+	/**
+	* FSRS specific parameters (17 parameters)
+	*/
+	getParameters: () => {
+		parameters: number[];
+		desiredRetention: number;
+		requestRetention: number;
+		maxInterval: number;
+	};
+	/**
+	* Calculate memory state (Difficulty, Stability, Retrievability)
+	*/
+	calculateMemoryState: (difficulty: number, stability: number, retrievability: number, rating: EFlashcardRating, deltaT: number) => {
+		newDifficulty: number;
+		newStability: number;
+		newRetrievability: number;
+	};
+	/**
+	* Calculate retrievability based on time elapsed
+	*/
+	calculateRetrievability: (stability: number, deltaT: number) => number;
+	/**
+	* Calculate next interval based on desired retention
+	*/
+	calculateInterval: (stability: number, desiredRetention: number) => number;
+	/**
+	* Initialize FSRS card state
+	*/
+	initializeFSRSCard: () => {
+		difficulty: number;
+		stability: number;
+		retrievability: number;
+	};
+	/**
+	* Optimize parameters based on review history
+	*/
+	optimizeParameters: (reviews: IFlashcardReview[]) => number[];
+	/**
+	* Evaluate parameter quality
+	*/
+	evaluateParameters: (reviews: IFlashcardReview[]) => {
+		logLoss: number;
+		rmse: number;
+	};
+}
+/**
+* Algorithm factory for creating algorithm instances
+*/
+interface IAlgorithmFactory {
+	/**
+	* Create SM-2 algorithm instance
+	*/
+	createSM2Algorithm: (parameters?: Partial<ISM2Algorithm["getParameters"]>) => ISM2Algorithm;
+	/**
+	* Create FSRS algorithm instance
+	*/
+	createFSRSAlgorithm: (parameters?: Partial<IFSRSAlgorithm["getParameters"]>) => IFSRSAlgorithm;
+	/**
+	* Get default parameters for an algorithm
+	*/
+	getDefaultParameters: (algorithm: "sm2" | "fsrs") => Record<string, unknown>;
+}
+/**
+* Algorithm utilities and helpers
+*/
+interface IAlgorithmUtils {
+	/**
+	* Apply fuzzing to interval (randomization)
+	*/
+	applyFuzzing: (interval: number, fuzzFactor?: number) => number;
+	/**
+	* Convert learning steps from minutes to intervals
+	*/
+	convertLearningSteps: (steps: number[]) => number[];
+	/**
+	* Calculate next due date
+	*/
+	calculateDueDate: (interval: number, baseDate?: Date) => Date;
+	/**
+	* Determine if interval should be fuzzed
+	*/
+	shouldApplyFuzzing: (interval: number) => boolean;
+	/**
+	* Clamp interval to valid range
+	*/
+	clampInterval: (interval: number, minInterval: number, maxInterval: number) => number;
+	/**
+	* Calculate average interval for multiple ratings
+	*/
+	calculateAverageInterval: (intervals: number[]) => number;
+}
+/**
+* Review statistics calculator
+*/
+interface IReviewStats {
+	/**
+	* Calculate retention rate from reviews
+	*/
+	calculateRetention: (reviews: IFlashcardReview[]) => number;
+	/**
+	* Calculate average response time
+	*/
+	calculateAverageResponseTime: (reviews: IFlashcardReview[]) => number;
+	/**
+	* Get rating distribution
+	*/
+	getRatingDistribution: (reviews: IFlashcardReview[]) => Record<EFlashcardRating, number>;
+	/**
+	* Calculate study load (cards per day)
+	*/
+	calculateStudyLoad: (cards: IFlashcard[]) => {
+		newCards: number;
+		learningCards: number;
+		reviewCards: number;
+		total: number;
+	};
+	/**
+	* Predict future workload
+	*/
+	predictWorkload: (cards: IFlashcard[], algorithm: ISpacedRepetitionAlgorithm, days: number) => {
+		date: Date;
+		newCards: number;
+		reviews: number;
+		total: number;
+	}[];
+}
+/**
+* Scheduler for managing card due dates and priorities
+*/
+interface ICardScheduler {
+	/**
+	* Get cards due for review
+	*/
+	getDueCards: (cards: IFlashcard[], maxCards?: number) => IFlashcard[];
+	/**
+	* Get new cards ready for learning
+	*/
+	getNewCards: (cards: IFlashcard[], maxCards?: number) => IFlashcard[];
+	/**
+	* Get learning cards ready for next step
+	*/
+	getLearningCards: (cards: IFlashcard[]) => IFlashcard[];
+	/**
+	* Sort cards by priority
+	*/
+	sortCardsByPriority: (cards: IFlashcard[], sortOrder: "due" | "random" | "added") => IFlashcard[];
+	/**
+	* Check if card is overdue
+	*/
+	isOverdue: (card: IFlashcard) => boolean;
+	/**
+	* Calculate overdue factor
+	*/
+	getOverdueFactor: (card: IFlashcard) => number;
+	/**
+	* Reschedule all cards with new algorithm
+	*/
+	rescheduleCards: (cards: IFlashcard[], algorithm: ISpacedRepetitionAlgorithm) => IFlashcard[];
+}
+/**
+* Default Anki algorithm constants
+*/
+declare const ANKI_DEFAULTS: {
+	readonly LEARNING_STEPS: readonly [1, 10];
+	readonly GRADUATING_INTERVAL: 1;
+	readonly EASY_INTERVAL: 4;
+	readonly STARTING_EASE_FACTOR: 2.5;
+	readonly EASY_BONUS: 1.3;
+	readonly INTERVAL_MODIFIER: 1.0;
+	readonly HARD_INTERVAL: 1.2;
+	readonly RELEARNING_STEPS: readonly [10];
+	readonly NEW_INTERVAL: 0.0;
+	readonly MINIMUM_INTERVAL: 1;
+	readonly LEECH_THRESHOLD: 8;
+	readonly MAX_NEW_CARDS_PER_DAY: 20;
+	readonly MAX_REVIEW_CARDS_PER_DAY: 200;
+	readonly MAX_ANSWER_TIME: 60;
+	readonly MIN_INTERVAL: 1;
+	readonly MAX_INTERVAL: 36500;
+	readonly DESIRED_RETENTION: 0.9;
+	readonly FSRS_DEFAULT_PARAMETERS: readonly [0.4072, 1.1829, 3.1262, 15.4722, 7.2102, 0.5316, 1.0651, 0.0234, 1.616, 0.1544, 1.0824, 1.9813, 0.0953, 0.2975, 2.2042, 0.2407, 2.9466];
+};
+/**
+* Rating multipliers for interval calculation
+*/
+declare const RATING_MULTIPLIERS: Record<EFlashcardRating, number>;
+/**
+* Ease factor adjustments based on rating
+*/
+declare const EASE_ADJUSTMENTS: Record<EFlashcardRating, number>;
+/**
+* Minimum and maximum ease factor bounds
+*/
+declare const EASE_BOUNDS: {
+	readonly MIN: 1.3;
+	readonly MAX: 2.5;
+};
+/**
+* Card state transitions based on rating
+*/
+declare const STATE_TRANSITIONS: Record<EFlashcardState, Record<EFlashcardRating, EFlashcardState>>;
+/**
+* Learning step multipliers for Hard button
+*/
+declare const LEARNING_HARD_MULTIPLIERS: {
+	readonly FIRST_STEP: 1.5;
+	readonly AVERAGE_STEPS: 0.5;
+};
+/**
+* Fuzz factor for randomizing intervals
+*/
+declare const FUZZ_FACTOR: {
+	readonly MIN: 0.95;
+	readonly MAX: 1.05;
+};
+/**
+* Session scoring weights
+*/
+declare const SCORE_WEIGHTS: Record<EFlashcardRating, number>;
+/**
+* Card maturity threshold (days)
+*/
+declare const MATURITY_THRESHOLD = 21;
+/**
+* Default preset configurations
+*/
+declare const DEFAULT_PRESETS: {
+	readonly BEGINNER: {
+		readonly name: "Beginner";
+		readonly description: "For new learners with more repetition";
+		readonly learningSteps: readonly [1, 10, 1440];
+		readonly graduatingInterval: 2;
+		readonly easyInterval: 7;
+		readonly maxNewCardsPerDay: 10;
+		readonly desiredRetention: 0.85;
+	};
+	readonly DEFAULT: {
+		readonly name: "Default";
+		readonly description: "Balanced settings for most users";
+		readonly learningSteps: readonly [1, 10];
+		readonly graduatingInterval: 1;
+		readonly easyInterval: 4;
+		readonly maxNewCardsPerDay: 20;
+		readonly desiredRetention: 0.9;
+	};
+	readonly INTENSIVE: {
+		readonly name: "Intensive";
+		readonly description: "For serious learners who want higher retention";
+		readonly learningSteps: readonly [1, 10];
+		readonly graduatingInterval: 1;
+		readonly easyInterval: 4;
+		readonly maxNewCardsPerDay: 30;
+		readonly desiredRetention: 0.95;
+	};
+	readonly LIGHT: {
+		readonly name: "Light";
+		readonly description: "For casual learning with fewer reviews";
+		readonly learningSteps: readonly [1, 10];
+		readonly graduatingInterval: 3;
+		readonly easyInterval: 7;
+		readonly maxNewCardsPerDay: 15;
+		readonly desiredRetention: 0.8;
+	};
+};
+/**
+* Algorithm-specific constants
+*/
+interface SM2Constants {
+	MIN_EASE_FACTOR: number;
+	MAX_EASE_FACTOR: number;
+	EASE_ADJUSTMENT_STEP: number;
+}
+interface FSRSConstants {
+	MIN_DIFFICULTY: number;
+	MAX_DIFFICULTY: number;
+	MIN_STABILITY: number;
+	MAX_STABILITY: number;
+	MIN_RETRIEVABILITY: number;
+	MAX_RETRIEVABILITY: number;
+}
+type AlgorithmConstants = {
+	[EFlashcardAlgorithm.SM2]: SM2Constants;
+	[EFlashcardAlgorithm.FSRS]: FSRSConstants;
+};
+declare const ALGORITHM_CONSTANTS: AlgorithmConstants;
+/**
+* Utility functions for common calculations
+*/
+declare const UTILS: {
+	/**
+	* Convert minutes to milliseconds
+	*/
+	readonly minutesToMs: (minutes: number) => number;
+	/**
+	* Convert days to milliseconds
+	*/
+	readonly daysToMs: (days: number) => number;
+	/**
+	* Apply fuzz factor to interval
+	*/
+	readonly applyFuzz: (interval: number) => number;
+	/**
+	* Clamp ease factor to valid range
+	*/
+	readonly clampEaseFactor: (ease: number) => number;
+	/**
+	* Calculate session score
+	*/
+	readonly calculateScore: (ratings: EFlashcardRating[]) => number;
+	/**
+	* Determine if card is mature
+	*/
+	readonly isMature: (interval: number) => boolean;
+};
+export { UTILS, STATE_TRANSITIONS, SCORE_WEIGHTS, RATING_MULTIPLIERS, MATURITY_THRESHOLD, LEARNING_HARD_MULTIPLIERS, ISpacedRepetitionAlgorithm, ISM2Algorithm, IReviewStats, IFlashcardStats, IFlashcardSession, IFlashcardSchedule, IFlashcardReview, IFlashcardPreset, IFlashcardDeck, IFlashcard, IFSRSAlgorithm, ICardScheduler, IAlgorithmUtils, IAlgorithmFactory, FUZZ_FACTOR, EFlashcardState, EFlashcardSessionStatus, EFlashcardRating, EFlashcardAlgorithm, EASE_BOUNDS, EASE_ADJUSTMENTS, DEFAULT_PRESETS, ANKI_DEFAULTS, ALGORITHM_CONSTANTS };

package/dist/flashcard/index.js

@@ -0,0 +1,3 @@
+var J;((f)=>{f.NEW="new";f.LEARNING="learning";f.RELEARNING="relearning";f.REVIEW="review";f.BURIED="buried";f.SUSPENDED="suspended"})(J||={});var K;((x)=>{x.AGAIN="again";x.HARD="hard";x.GOOD="good";x.EASY="easy"})(K||={});var b;((x)=>{x.DRAFT="draft";x.STARTED="started";x.PAUSED="paused";x.COMPLETED="completed"})(b||={});var Q;((j)=>{j.SM2="sm2";j.FSRS="fsrs"})(Q||={});var w={LEARNING_STEPS:[1,10],GRADUATING_INTERVAL:1,EASY_INTERVAL:4,STARTING_EASE_FACTOR:2.5,EASY_BONUS:1.3,INTERVAL_MODIFIER:1,HARD_INTERVAL:1.2,RELEARNING_STEPS:[10],NEW_INTERVAL:0,MINIMUM_INTERVAL:1,LEECH_THRESHOLD:8,MAX_NEW_CARDS_PER_DAY:20,MAX_REVIEW_CARDS_PER_DAY:200,MAX_ANSWER_TIME:60,MIN_INTERVAL:1,MAX_INTERVAL:36500,DESIRED_RETENTION:0.9,FSRS_DEFAULT_PARAMETERS:[0.4072,1.1829,3.1262,15.4722,7.2102,0.5316,1.0651,0.0234,1.616,0.1544,1.0824,1.9813,0.0953,0.2975,2.2042,0.2407,2.9466]},z=Object.freeze({again:0,hard:1.2,good:2.5,easy:3.25}),B=Object.freeze({again:-0.2,hard:-0.15,good:0,easy:0.15}),V={MIN:1.3,MAX:2.5},G=Object.freeze({new:Object.freeze({again:"learning",hard:"learning",good:"learning",easy:"review"}),learning:Object.freeze({again:"learning",hard:"learning",good:"learning",easy:"review"}),review:Object.freeze({again:"relearning",hard:"review",good:"review",easy:"review"}),relearning:Object.freeze({again:"relearning",hard:"relearning",good:"relearning",easy:"review"}),buried:Object.freeze({again:"buried",hard:"buried",good:"buried",easy:"buried"}),suspended:Object.freeze({again:"suspended",hard:"suspended",good:"suspended",easy:"suspended"})}),N={FIRST_STEP:1.5,AVERAGE_STEPS:0.5},q={MIN:0.95,MAX:1.05},X=Object.freeze({again:0,hard:50,good:80,easy:100}),L=21,P={BEGINNER:{name:"Beginner",description:"For new learners with more repetition",learningSteps:[1,10,1440],graduatingInterval:2,easyInterval:7,maxNewCardsPerDay:10,desiredRetention:0.85},DEFAULT:{name:"Default",description:"Balanced settings for most users",learningSteps:[1,10],graduatingInterval:1,easyInterval:4,maxNewCardsPerDay:20,desiredRetention:0.9},INTENSIVE:{name:"Intensive",description:"For serious learners who want higher retention",learningSteps:[1,10],graduatingInterval:1,easyInterval:4,maxNewCardsPerDay:30,desiredRetention:0.95},LIGHT:{name:"Light",description:"For casual learning with fewer reviews",learningSteps:[1,10],graduatingInterval:3,easyInterval:7,maxNewCardsPerDay:15,desiredRetention:0.8}},W=Object.freeze({sm2:Object.freeze({MIN_EASE_FACTOR:1.3,MAX_EASE_FACTOR:2.5,EASE_ADJUSTMENT_STEP:0.15}),fsrs:Object.freeze({MIN_DIFFICULTY:1,MAX_DIFFICULTY:10,MIN_STABILITY:0.1,MAX_STABILITY:36500,MIN_RETRIEVABILITY:0.01,MAX_RETRIEVABILITY:0.99})}),y={minutesToMs:(p)=>p*60*1000,daysToMs:(p)=>p*24*60*60*1000,applyFuzz:(p)=>{let k=q.MIN+Math.random()*(q.MAX-q.MIN);return Math.max(1,Math.round(p*k))},clampEaseFactor:(p)=>{return Math.max(V.MIN,Math.min(p,V.MAX))},calculateScore:(p)=>{if(p.length===0)return 0;let k=p.reduce(($,x)=>$+X[x],0),j=p.length*X["easy"];return Math.round(k/j*100)},isMature:(p)=>p>=L};export{y as UTILS,G as STATE_TRANSITIONS,X as SCORE_WEIGHTS,z as RATING_MULTIPLIERS,L as MATURITY_THRESHOLD,N as LEARNING_HARD_MULTIPLIERS,q as FUZZ_FACTOR,J as EFlashcardState,b as EFlashcardSessionStatus,K as EFlashcardRating,Q as EFlashcardAlgorithm,V as EASE_BOUNDS,B as EASE_ADJUSTMENTS,P as DEFAULT_PRESETS,w as ANKI_DEFAULTS,W as ALGORITHM_CONSTANTS};
+
+//# debugId=38A76FAEB9774D5664756E2164756E21

package/dist/flashcard/index.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["src/flashcard/types.ts", "src/flashcard/constants.ts"],
+  "sourcesContent": [
+    "import type { IImage } from \"@ooneex/image\";\nimport type { IStatus } from \"@ooneex/status\";\nimport type { ITag } from \"@ooneex/tag\";\nimport type { IBase, IStat } from \"@ooneex/types\";\nimport type { ESessionType, ILevel } from \"../types\";\n\nexport enum EFlashcardState {\n  /** Brand new card that hasn't been studied yet */\n  NEW = \"new\",\n  /** Card in learning phase with short intervals */\n  LEARNING = \"learning\",\n  /** Card in relearning phase after being forgotten */\n  RELEARNING = \"relearning\",\n  /** Graduated card in long-term review cycle */\n  REVIEW = \"review\",\n  /** Card temporarily hidden until next day */\n  BURIED = \"buried\",\n  /** Card permanently hidden from reviews */\n  SUSPENDED = \"suspended\",\n}\n\nexport enum EFlashcardRating {\n  /** Incorrect answer - restart learning */\n  AGAIN = \"again\",\n  /** Correct but difficult - shorter interval */\n  HARD = \"hard\",\n  /** Correct with some effort - normal interval */\n  GOOD = \"good\",\n  /** Correct with no effort - longer interval */\n  EASY = \"easy\",\n}\n\nexport enum EFlashcardSessionStatus {\n  DRAFT = \"draft\",\n  STARTED = \"started\",\n  PAUSED = \"paused\",\n  COMPLETED = \"completed\",\n}\n\nexport enum EFlashcardAlgorithm {\n  /** Legacy SuperMemo 2 algorithm */\n  SM2 = \"sm2\",\n  /** Free Spaced Repetition Scheduler (modern) */\n  FSRS = \"fsrs\",\n}\n\nexport interface IFlashcardSchedule extends IBase {\n  /** Current state of the card */\n  state: EFlashcardState;\n  /** Days until next review */\n  interval: number;\n  /** Ease factor for SM-2 algorithm (2.5 = 250%) */\n  easeFactor: number;\n  /** Number of times card has been reviewed */\n  reviewCount: number;\n  /** Number of times card has failed (lapses) */\n  lapseCount: number;\n  /** Current step in learning/relearning sequence */\n  currentStep: number;\n  /** When the card is due for review */\n  dueDate: Date;\n  /** Last time the card was reviewed */\n  lastReviewedAt?: Date | null;\n  /** FSRS-specific parameters */\n  difficulty?: number; // FSRS difficulty (0-10)\n  stability?: number; // FSRS stability in days\n  retrievability?: number; // FSRS retrievability (0-1)\n  /** Learning steps for this card (in minutes) */\n  learningSteps: number[];\n  /** Relearning steps for this card (in minutes) */\n  relearningSteps: number[];\n}\n\nexport interface IFlashcard extends IBase {\n  /** Front side content */\n  front: string;\n  /** Back side content */\n  back: string;\n  /** Optional hint text */\n  hint?: string;\n  /** Optional context or source */\n  context?: string;\n  contextId?: string;\n  /** Scheduling information */\n  schedule: IFlashcardSchedule;\n  /** Additional metadata */\n  tags?: ITag[];\n  stat?: IStat;\n  status?: IStatus;\n  image?: IImage;\n}\n\nexport interface IFlashcardReview extends IBase {\n  /** The flashcard being reviewed */\n  card: IFlashcard;\n  /** Session this review belongs to */\n  session: IFlashcardSession;\n  /** User's rating for this review */\n  rating: EFlashcardRating;\n  /** Time taken to answer (in seconds) */\n  responseTime: number;\n  /** Previous interval before this review */\n  previousInterval: number;\n  /** New interval after this review */\n  newInterval: number;\n  /** Previous ease factor */\n  previousEaseFactor: number;\n  /** New ease factor */\n  newEaseFactor: number;\n  /** Previous due date */\n  previousDueDate: Date;\n  /** New due date */\n  newDueDate: Date;\n  /** Previous card state */\n  previousState: EFlashcardState;\n  /** New card state */\n  newState: EFlashcardState;\n  /** Whether this was a lapse (forgotten card) */\n  wasLapse: boolean;\n  /** Algorithm used for scheduling */\n  algorithm: EFlashcardAlgorithm;\n  /** Review timestamp */\n  reviewedAt: Date;\n}\n\nexport interface IFlashcardSession extends IBase {\n  name: string;\n  /** Total cards available for study */\n  totalCards: number;\n  /** Number of new cards in session */\n  newCardsCount: number;\n  /** Number of learning cards in session */\n  learningCardsCount: number;\n  /** Number of review cards in session */\n  reviewCardsCount: number;\n  /** Cards studied so far */\n  studiedCount: number;\n  /** Cards answered correctly */\n  correctCount: number;\n  /** Cards answered incorrectly */\n  incorrectCount: number;\n  /** Total study time in seconds */\n  studyTime: number;\n  /** Cards in this session */\n  cards: IFlashcard[];\n  /** Reviews completed in this session */\n  reviews: IFlashcardReview[];\n  /** Session status */\n  status: EFlashcardSessionStatus;\n  /** Overall session score (0-100) */\n  score: number;\n  /** Session start time */\n  startedAt?: Date | null;\n  /** Session pause time */\n  pausedAt?: Date | null;\n  /** Session resume time */\n  resumedAt?: Date | null;\n  /** Session completion time */\n  completedAt?: Date | null;\n  /** Type of study session */\n  type: ESessionType;\n  /** Difficulty level */\n  level: ILevel;\n  /** Algorithm configuration */\n  algorithm: EFlashcardAlgorithm;\n  /** Maximum new cards per session */\n  maxNewCards: number;\n  /** Maximum review cards per session */\n  maxReviewCards: number;\n  /** Desired retention rate (0-1) for FSRS */\n  desiredRetention: number;\n  /** Learning steps (in minutes) */\n  learningSteps: number[];\n  /** Graduating interval (in days) */\n  graduatingInterval: number;\n  /** Easy interval (in days) */\n  easyInterval: number;\n  /** Maximum interval (in days) */\n  maxInterval: number;\n}\n\nexport interface IFlashcardDeck extends IBase {\n  name: string;\n  description?: string;\n  /** Total cards in deck */\n  totalCards: number;\n  /** New cards ready to learn */\n  newCards: number;\n  /** Cards in learning phase */\n  learningCards: number;\n  /** Cards due for review today */\n  dueCards: number;\n  /** Cards suspended */\n  suspendedCards: number;\n  /** All flashcards in this deck */\n  cards: IFlashcard[];\n  /** Deck settings */\n  algorithm: EFlashcardAlgorithm;\n  maxNewCardsPerDay: number;\n  maxReviewCardsPerDay: number;\n  desiredRetention: number;\n  learningSteps: number[];\n  relearningSteps: number[];\n  graduatingInterval: number;\n  easyInterval: number;\n  maxInterval: number;\n  /** FSRS parameters (17 parameters) */\n  fsrsParameters?: number[];\n  /** Leech threshold (number of lapses before marking as leech) */\n  leechThreshold: number;\n  /** Whether to bury sibling cards */\n  burySiblings: boolean;\n  /** Deck statistics */\n  stat?: IStat;\n  status?: IStatus;\n}\n\nexport interface IFlashcardPreset extends IBase {\n  name: string;\n  description?: string;\n  /** Algorithm to use */\n  algorithm: EFlashcardAlgorithm;\n  /** Learning configuration */\n  learningSteps: number[];\n  relearningSteps: number[];\n  graduatingInterval: number;\n  easyInterval: number;\n  maxInterval: number;\n  /** Daily limits */\n  maxNewCardsPerDay: number;\n  maxReviewCardsPerDay: number;\n  /** FSRS configuration */\n  desiredRetention: number;\n  fsrsParameters?: number[];\n  /** SM-2 configuration */\n  startingEaseFactor: number;\n  easyBonus: number;\n  intervalModifier: number;\n  hardInterval: number;\n  newInterval: number;\n  /** Lapse configuration */\n  minimumInterval: number;\n  leechThreshold: number;\n  /** Display options */\n  burySiblings: boolean;\n  showTimer: boolean;\n  autoPlayAudio: boolean;\n}\n\nexport interface IFlashcardStats extends IBase {\n  /** Cards studied today */\n  cardsStudiedToday: number;\n  /** Time spent studying today (minutes) */\n  timeSpentToday: number;\n  /** Current streak (days) */\n  currentStreak: number;\n  /** Longest streak (days) */\n  longestStreak: number;\n  /** Total reviews all time */\n  totalReviews: number;\n  /** Total study time all time (minutes) */\n  totalStudyTime: number;\n  /** Average retention rate */\n  retentionRate: number;\n  /** Breakdown by card state */\n  newCardsCount: number;\n  learningCardsCount: number;\n  reviewCardsCount: number;\n  suspendedCardsCount: number;\n  /** Maturity statistics */\n  matureCardsCount: number; // Cards with interval >= 21 days\n  youngCardsCount: number; // Cards with interval < 21 days\n  /** Performance by rating */\n  againCount: number;\n  hardCount: number;\n  goodCount: number;\n  easyCount: number;\n  /** Date range for these stats */\n  startDate: Date;\n  endDate: Date;\n}\n",
+    "import { EFlashcardAlgorithm, EFlashcardRating, EFlashcardState } from \"./types\";\n\n/**\n * Default Anki algorithm constants\n */\nexport const ANKI_DEFAULTS = {\n  // Learning phase\n  LEARNING_STEPS: [1, 10], // 1 minute, 10 minutes\n  GRADUATING_INTERVAL: 1, // 1 day\n  EASY_INTERVAL: 4, // 4 days\n\n  // Review phase (SM-2)\n  STARTING_EASE_FACTOR: 2.5, // 250%\n  EASY_BONUS: 1.3, // 130%\n  INTERVAL_MODIFIER: 1.0, // 100%\n  HARD_INTERVAL: 1.2, // 120%\n\n  // Lapses\n  RELEARNING_STEPS: [10], // 10 minutes\n  NEW_INTERVAL: 0.0, // 0% of previous interval\n  MINIMUM_INTERVAL: 1, // 1 day\n  LEECH_THRESHOLD: 8, // 8 lapses\n\n  // Daily limits\n  MAX_NEW_CARDS_PER_DAY: 20,\n  MAX_REVIEW_CARDS_PER_DAY: 200,\n\n  // Timing\n  MAX_ANSWER_TIME: 60, // 60 seconds\n  MIN_INTERVAL: 1, // 1 day minimum\n  MAX_INTERVAL: 36500, // 100 years\n\n  // FSRS\n  DESIRED_RETENTION: 0.9, // 90%\n  FSRS_DEFAULT_PARAMETERS: [\n    0.4072, 1.1829, 3.1262, 15.4722, 7.2102, 0.5316, 1.0651, 0.0234, 1.616, 0.1544, 1.0824, 1.9813, 0.0953, 0.2975,\n    2.2042, 0.2407, 2.9466,\n  ],\n} as const;\n\n/**\n * Rating multipliers for interval calculation\n */\nexport const RATING_MULTIPLIERS: Record<EFlashcardRating, number> = Object.freeze({\n  [EFlashcardRating.AGAIN]: 0, // Reset to learning\n  [EFlashcardRating.HARD]: 1.2,\n  [EFlashcardRating.GOOD]: 2.5, // Default ease factor\n  [EFlashcardRating.EASY]: 2.5 * 1.3, // Easy bonus applied\n});\n\n/**\n * Ease factor adjustments based on rating\n */\nexport const EASE_ADJUSTMENTS: Record<EFlashcardRating, number> = Object.freeze({\n  [EFlashcardRating.AGAIN]: -0.2, // Decrease ease by 20%\n  [EFlashcardRating.HARD]: -0.15, // Decrease ease by 15%\n  [EFlashcardRating.GOOD]: 0, // No change\n  [EFlashcardRating.EASY]: 0.15, // Increase ease by 15%\n});\n\n/**\n * Minimum and maximum ease factor bounds\n */\nexport const EASE_BOUNDS = {\n  MIN: 1.3, // 130% minimum\n  MAX: 2.5, // 250% maximum (no upper bound in practice)\n} as const;\n\n/**\n * Card state transitions based on rating\n */\nexport const STATE_TRANSITIONS: Record<EFlashcardState, Record<EFlashcardRating, EFlashcardState>> = Object.freeze({\n  [EFlashcardState.NEW]: Object.freeze({\n    [EFlashcardRating.AGAIN]: EFlashcardState.LEARNING,\n    [EFlashcardRating.HARD]: EFlashcardState.LEARNING,\n    [EFlashcardRating.GOOD]: EFlashcardState.LEARNING,\n    [EFlashcardRating.EASY]: EFlashcardState.REVIEW,\n  }),\n  [EFlashcardState.LEARNING]: Object.freeze({\n    [EFlashcardRating.AGAIN]: EFlashcardState.LEARNING, // Restart learning\n    [EFlashcardRating.HARD]: EFlashcardState.LEARNING, // Repeat current step\n    [EFlashcardRating.GOOD]: EFlashcardState.LEARNING, // Next step or graduate\n    [EFlashcardRating.EASY]: EFlashcardState.REVIEW, // Skip to review\n  }),\n  [EFlashcardState.REVIEW]: Object.freeze({\n    [EFlashcardRating.AGAIN]: EFlashcardState.RELEARNING,\n    [EFlashcardRating.HARD]: EFlashcardState.REVIEW,\n    [EFlashcardRating.GOOD]: EFlashcardState.REVIEW,\n    [EFlashcardRating.EASY]: EFlashcardState.REVIEW,\n  }),\n  [EFlashcardState.RELEARNING]: Object.freeze({\n    [EFlashcardRating.AGAIN]: EFlashcardState.RELEARNING, // Restart relearning\n    [EFlashcardRating.HARD]: EFlashcardState.RELEARNING, // Repeat current step\n    [EFlashcardRating.GOOD]: EFlashcardState.RELEARNING, // Next step or back to review\n    [EFlashcardRating.EASY]: EFlashcardState.REVIEW, // Skip to review\n  }),\n  [EFlashcardState.BURIED]: Object.freeze({\n    [EFlashcardRating.AGAIN]: EFlashcardState.BURIED, // Remains buried\n    [EFlashcardRating.HARD]: EFlashcardState.BURIED, // Remains buried\n    [EFlashcardRating.GOOD]: EFlashcardState.BURIED, // Remains buried\n    [EFlashcardRating.EASY]: EFlashcardState.BURIED, // Remains buried\n  }),\n  [EFlashcardState.SUSPENDED]: Object.freeze({\n    [EFlashcardRating.AGAIN]: EFlashcardState.SUSPENDED, // Remains suspended\n    [EFlashcardRating.HARD]: EFlashcardState.SUSPENDED, // Remains suspended\n    [EFlashcardRating.GOOD]: EFlashcardState.SUSPENDED, // Remains suspended\n    [EFlashcardRating.EASY]: EFlashcardState.SUSPENDED, // Remains suspended\n  }),\n});\n\n/**\n * Learning step multipliers for Hard button\n */\nexport const LEARNING_HARD_MULTIPLIERS = {\n  FIRST_STEP: 1.5, // 150% of first step when only one step\n  AVERAGE_STEPS: 0.5, // 50% of average between current and next step\n} as const;\n\n/**\n * Fuzz factor for randomizing intervals\n */\nexport const FUZZ_FACTOR = {\n  MIN: 0.95, // 95% of calculated interval\n  MAX: 1.05, // 105% of calculated interval\n} as const;\n\n/**\n * Session scoring weights\n */\nexport const SCORE_WEIGHTS: Record<EFlashcardRating, number> = Object.freeze({\n  [EFlashcardRating.AGAIN]: 0, // 0 points\n  [EFlashcardRating.HARD]: 50, // 50 points\n  [EFlashcardRating.GOOD]: 80, // 80 points\n  [EFlashcardRating.EASY]: 100, // 100 points\n});\n\n/**\n * Card maturity threshold (days)\n */\nexport const MATURITY_THRESHOLD = 21; // Cards with interval >= 21 days are mature\n\n/**\n * Default preset configurations\n */\nexport const DEFAULT_PRESETS = {\n  BEGINNER: {\n    name: \"Beginner\",\n    description: \"For new learners with more repetition\",\n    learningSteps: [1, 10, 1440], // 1m, 10m, 1d\n    graduatingInterval: 2,\n    easyInterval: 7,\n    maxNewCardsPerDay: 10,\n    desiredRetention: 0.85,\n  },\n  DEFAULT: {\n    name: \"Default\",\n    description: \"Balanced settings for most users\",\n    learningSteps: [1, 10], // 1m, 10m\n    graduatingInterval: 1,\n    easyInterval: 4,\n    maxNewCardsPerDay: 20,\n    desiredRetention: 0.9,\n  },\n  INTENSIVE: {\n    name: \"Intensive\",\n    description: \"For serious learners who want higher retention\",\n    learningSteps: [1, 10], // 1m, 10m\n    graduatingInterval: 1,\n    easyInterval: 4,\n    maxNewCardsPerDay: 30,\n    desiredRetention: 0.95,\n  },\n  LIGHT: {\n    name: \"Light\",\n    description: \"For casual learning with fewer reviews\",\n    learningSteps: [1, 10], // 1m, 10m\n    graduatingInterval: 3,\n    easyInterval: 7,\n    maxNewCardsPerDay: 15,\n    desiredRetention: 0.8,\n  },\n} as const;\n\n/**\n * Algorithm-specific constants\n */\ninterface SM2Constants {\n  MIN_EASE_FACTOR: number;\n  MAX_EASE_FACTOR: number;\n  EASE_ADJUSTMENT_STEP: number;\n}\n\ninterface FSRSConstants {\n  MIN_DIFFICULTY: number;\n  MAX_DIFFICULTY: number;\n  MIN_STABILITY: number;\n  MAX_STABILITY: number;\n  MIN_RETRIEVABILITY: number;\n  MAX_RETRIEVABILITY: number;\n}\n\ntype AlgorithmConstants = {\n  [EFlashcardAlgorithm.SM2]: SM2Constants;\n  [EFlashcardAlgorithm.FSRS]: FSRSConstants;\n};\n\nexport const ALGORITHM_CONSTANTS: AlgorithmConstants = Object.freeze({\n  [EFlashcardAlgorithm.SM2]: Object.freeze({\n    MIN_EASE_FACTOR: 1.3,\n    MAX_EASE_FACTOR: 2.5,\n    EASE_ADJUSTMENT_STEP: 0.15,\n  }),\n  [EFlashcardAlgorithm.FSRS]: Object.freeze({\n    MIN_DIFFICULTY: 1,\n    MAX_DIFFICULTY: 10,\n    MIN_STABILITY: 0.1,\n    MAX_STABILITY: 36500,\n    MIN_RETRIEVABILITY: 0.01,\n    MAX_RETRIEVABILITY: 0.99,\n  }),\n});\n\n/**\n * Utility functions for common calculations\n */\nexport const UTILS = {\n  /**\n   * Convert minutes to milliseconds\n   */\n  minutesToMs: (minutes: number): number => minutes * 60 * 1000,\n\n  /**\n   * Convert days to milliseconds\n   */\n  daysToMs: (days: number): number => days * 24 * 60 * 60 * 1000,\n\n  /**\n   * Apply fuzz factor to interval\n   */\n  applyFuzz: (interval: number): number => {\n    const fuzz = FUZZ_FACTOR.MIN + Math.random() * (FUZZ_FACTOR.MAX - FUZZ_FACTOR.MIN);\n    return Math.max(1, Math.round(interval * fuzz));\n  },\n\n  /**\n   * Clamp ease factor to valid range\n   */\n  clampEaseFactor: (ease: number): number => {\n    return Math.max(EASE_BOUNDS.MIN, Math.min(ease, EASE_BOUNDS.MAX));\n  },\n\n  /**\n   * Calculate session score\n   */\n  calculateScore: (ratings: EFlashcardRating[]): number => {\n    if (ratings.length === 0) return 0;\n    const totalPoints = ratings.reduce((sum, rating) => sum + SCORE_WEIGHTS[rating], 0);\n    const maxPossible = ratings.length * SCORE_WEIGHTS[EFlashcardRating.EASY];\n    return Math.round((totalPoints / maxPossible) * 100);\n  },\n\n  /**\n   * Determine if card is mature\n   */\n  isMature: (interval: number): boolean => interval >= MATURITY_THRESHOLD,\n} as const;\n"
+  ],
+  "mappings": "AAMO,IAAK,GAAL,CAAK,IAAL,CAEL,MAAM,MAEN,WAAW,WAEX,aAAa,aAEb,SAAS,SAET,SAAS,SAET,YAAY,cAZF,QAeL,IAAK,GAAL,CAAK,IAAL,CAEL,QAAQ,QAER,OAAO,OAEP,OAAO,OAEP,OAAO,SARG,QAWL,IAAK,GAAL,CAAK,IAAL,CACL,QAAQ,QACR,UAAU,UACV,SAAS,SACT,YAAY,cAJF,QAOL,IAAK,GAAL,CAAK,IAAL,CAEL,MAAM,MAEN,OAAO,SAJG,QClCL,IAAM,EAAgB,CAE3B,eAAgB,CAAC,EAAG,EAAE,EACtB,oBAAqB,EACrB,cAAe,EAGf,qBAAsB,IACtB,WAAY,IACZ,kBAAmB,EACnB,cAAe,IAGf,iBAAkB,CAAC,EAAE,EACrB,aAAc,EACd,iBAAkB,EAClB,gBAAiB,EAGjB,sBAAuB,GACvB,yBAA0B,IAG1B,gBAAiB,GACjB,aAAc,EACd,aAAc,MAGd,kBAAmB,IACnB,wBAAyB,CACvB,OAAQ,OAAQ,OAAQ,QAAS,OAAQ,OAAQ,OAAQ,OAAQ,MAAO,OAAQ,OAAQ,OAAQ,OAAQ,OACxG,OAAQ,OAAQ,MAClB,CACF,EAKa,EAAuD,OAAO,OAAO,CAC/E,MAAyB,EACzB,KAAwB,IACxB,KAAwB,IACxB,KAAwB,IAC3B,CAAC,EAKY,EAAqD,OAAO,OAAO,CAC7E,MAAyB,KACzB,KAAwB,MACxB,KAAwB,EACxB,KAAwB,IAC3B,CAAC,EAKY,EAAc,CACzB,IAAK,IACL,IAAK,GACP,EAKa,EAAwF,OAAO,OAAO,CAChH,IAAsB,OAAO,OAAO,CAClC,iBACA,gBACA,gBACA,aACH,CAAC,EACA,SAA2B,OAAO,OAAO,CACvC,iBACA,gBACA,gBACA,aACH,CAAC,EACA,OAAyB,OAAO,OAAO,CACrC,mBACA,cACA,cACA,aACH,CAAC,EACA,WAA6B,OAAO,OAAO,CACzC,mBACA,kBACA,kBACA,aACH,CAAC,EACA,OAAyB,OAAO,OAAO,CACrC,eACA,cACA,cACA,aACH,CAAC,EACA,UAA4B,OAAO,OAAO,CACxC,kBACA,iBACA,iBACA,gBACH,CAAC,CACH,CAAC,EAKY,EAA4B,CACvC,WAAY,IACZ,cAAe,GACjB,EAKa,EAAc,CACzB,IAAK,KACL,IAAK,IACP,EAKa,EAAkD,OAAO,OAAO,CAC1E,MAAyB,EACzB,KAAwB,GACxB,KAAwB,GACxB,KAAwB,GAC3B,CAAC,EAKY,EAAqB,GAKrB,EAAkB,CAC7B,SAAU,CACR,KAAM,WACN,YAAa,wCACb,cAAe,CAAC,EAAG,GAAI,IAAI,EAC3B,mBAAoB,EACpB,aAAc,EACd,kBAAmB,GACnB,iBAAkB,IACpB,EACA,QAAS,CACP,KAAM,UACN,YAAa,mCACb,cAAe,CAAC,EAAG,EAAE,EACrB,mBAAoB,EACpB,aAAc,EACd,kBAAmB,GACnB,iBAAkB,GACpB,EACA,UAAW,CACT,KAAM,YACN,YAAa,iDACb,cAAe,CAAC,EAAG,EAAE,EACrB,mBAAoB,EACpB,aAAc,EACd,kBAAmB,GACnB,iBAAkB,IACpB,EACA,MAAO,CACL,KAAM,QACN,YAAa,yCACb,cAAe,CAAC,EAAG,EAAE,EACrB,mBAAoB,EACpB,aAAc,EACd,kBAAmB,GACnB,iBAAkB,GACpB,CACF,EAyBa,EAA0C,OAAO,OAAO,CAClE,IAA0B,OAAO,OAAO,CACvC,gBAAiB,IACjB,gBAAiB,IACjB,qBAAsB,IACxB,CAAC,EACA,KAA2B,OAAO,OAAO,CACxC,eAAgB,EAChB,eAAgB,GAChB,cAAe,IACf,cAAe,MACf,mBAAoB,KACpB,mBAAoB,IACtB,CAAC,CACH,CAAC,EAKY,EAAQ,CAInB,YAAa,CAAC,IAA4B,EAAU,GAAK,KAKzD,SAAU,CAAC,IAAyB,EAAO,GAAK,GAAK,GAAK,KAK1D,UAAW,CAAC,IAA6B,CACvC,IAAM,EAAO,EAAY,IAAM,KAAK,OAAO,GAAK,EAAY,IAAM,EAAY,KAC9E,OAAO,KAAK,IAAI,EAAG,KAAK,MAAM,EAAW,CAAI,CAAC,GAMhD,gBAAiB,CAAC,IAAyB,CACzC,OAAO,KAAK,IAAI,EAAY,IAAK,KAAK,IAAI,EAAM,EAAY,GAAG,CAAC,GAMlE,eAAgB,CAAC,IAAwC,CACvD,GAAI,EAAQ,SAAW,EAAG,MAAO,GACjC,IAAM,EAAc,EAAQ,OAAO,CAAC,EAAK,IAAW,EAAM,EAAc,GAAS,CAAC,EAC5E,EAAc,EAAQ,OAAS,EAAc,QACnD,OAAO,KAAK,MAAO,EAAc,EAAe,GAAG,GAMrD,SAAU,CAAC,IAA8B,GAAY,CACvD",
+  "debugId": "38A76FAEB9774D5664756E2164756E21",
+  "names": []
+}

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import { IBase } from "@ooneex/types";
+interface ILevel extends IBase {
+	name: string;
+	code: string;
+	color: string;
+}
+declare enum ESessionType {
+	/** Learning-focused session with detailed explanations and guided experience */
+	TRAINING = "training",
+	/** Reinforcement session for solidifying already learned knowledge */
+	PRACTICE = "practice",
+	/** Mock test environment simulating real exam conditions */
+	SIMULATION = "simulation",
+	/** Quick knowledge check with immediate feedback */
+	QUIZ = "quiz",
+	/** Competitive or difficult questions designed to test limits */
+	CHALLENGE = "challenge",
+	/** Multiplayer competitive session with rankings and prizes */
+	TOURNAMENT = "tournament",
+	/** Session for revisiting previously answered questions and mistakes */
+	REVIEW = "review",
+	/** Initial assessment to identify knowledge gaps and skill levels */
+	DIAGNOSTIC = "diagnostic",
+	/** Time-pressured rapid-fire questions focusing on speed and accuracy */
+	SPEED_TEST = "speed_test"
+}
+declare enum EAnswerState {
+	CORRECT = "correct",
+	INCORRECT = "incorrect"
+}
+type SessionTypeItem = {
+	readonly code: ESessionType;
+	readonly name: string;
+	readonly description: string;
+	readonly color: string;
+};
+declare const SESSION_TYPES_EN: readonly SessionTypeItem[];
+declare const SESSION_TYPES_FR: readonly SessionTypeItem[];
+declare const SESSION_TYPES_RO: readonly SessionTypeItem[];
+export { SESSION_TYPES_RO, SESSION_TYPES_FR, SESSION_TYPES_EN, ILevel, ESessionType, EAnswerState };

package/dist/index.js

@@ -0,0 +1,3 @@
+var n;((e)=>{e.TRAINING="training";e.PRACTICE="practice";e.SIMULATION="simulation";e.QUIZ="quiz";e.CHALLENGE="challenge";e.TOURNAMENT="tournament";e.REVIEW="review";e.DIAGNOSTIC="diagnostic";e.SPEED_TEST="speed_test"})(n||={});var o;((i)=>{i.CORRECT="correct";i.INCORRECT="incorrect"})(o||={});var s=[{code:"training",name:"Training",description:"Learning-focused session with detailed explanations and guided experience. Perfect for acquiring new knowledge and understanding complex concepts step by step.",color:"#3b82f6"},{code:"practice",name:"Practice",description:"Reinforcement session for solidifying already learned knowledge. Helps strengthen understanding through repetition and application of learned concepts.",color:"#10b981"},{code:"simulation",name:"Simulation",description:"Mock test environment simulating real exam conditions. Provides realistic practice experience with authentic timing and pressure conditions.",color:"#f59e0b"},{code:"quiz",name:"Quiz",description:"Quick knowledge check with immediate feedback. Short and focused sessions to assess current understanding and identify areas for improvement.",color:"#8b5cf6"},{code:"challenge",name:"Challenge",description:"Competitive or difficult questions designed to test limits. Advanced sessions that push your knowledge boundaries and critical thinking skills.",color:"#ef4444"},{code:"tournament",name:"Tournament",description:"Multiplayer competitive session with rankings and prizes. Compete against other players in real-time for leaderboard positions and rewards.",color:"#f59e0b"},{code:"review",name:"Review",description:"Session for revisiting previously answered questions and mistakes. Focused practice on areas where improvement is needed based on past performance.",color:"#6b7280"},{code:"diagnostic",name:"Diagnostic",description:"Initial assessment to identify knowledge gaps and skill levels. Comprehensive evaluation to create a personalized learning path.",color:"#06b6d4"},{code:"speed_test",name:"Speed Test",description:"Time-pressured rapid-fire questions focusing on speed and accuracy. Develops quick thinking and decision-making skills under time constraints.",color:"#ec4899"}],t=[{code:"training",name:"Formation",description:"Session d'apprentissage avec explications détaillées et expérience guidée. Parfait pour acquérir de nouvelles connaissances et comprendre des concepts complexes étape par étape.",color:"#3b82f6"},{code:"practice",name:"Pratique",description:"Session de renforcement pour consolider les connaissances déjà apprises. Aide à renforcer la compréhension par la répétition et l'application des concepts appris.",color:"#10b981"},{code:"simulation",name:"Simulation",description:"Environnement d'examen simulé reproduisant les conditions réelles d'examen. Offre une expérience de pratique réaliste avec un timing et une pression authentiques.",color:"#f59e0b"},{code:"quiz",name:"Quiz",description:"Contrôle rapide des connaissances avec feedback immédiat. Sessions courtes et ciblées pour évaluer la compréhension actuelle et identifier les domaines à améliorer.",color:"#8b5cf6"},{code:"challenge",name:"Défi",description:"Questions compétitives ou difficiles conçues pour tester les limites. Sessions avancées qui repoussent vos limites de connaissances et vos compétences de pensée critique.",color:"#ef4444"},{code:"tournament",name:"Tournoi",description:"Session compétitive multijoueur avec classements et prix. Affrontez d'autres joueurs en temps réel pour des positions au classement et des récompenses.",color:"#f59e0b"},{code:"review",name:"Révision",description:"Session pour revoir les questions précédemment répondues et les erreurs. Pratique ciblée sur les domaines nécessitant une amélioration basée sur les performances passées.",color:"#6b7280"},{code:"diagnostic",name:"Diagnostic",description:"Évaluation initiale pour identifier les lacunes de connaissances et les niveaux de compétences. Évaluation complète pour créer un parcours d'apprentissage personnalisé.",color:"#06b6d4"},{code:"speed_test",name:"Test de Vitesse",description:"Questions rapides sous pression temporelle axées sur la vitesse et la précision. Développe la pensée rapide et les compétences de prise de décision sous contraintes de temps.",color:"#ec4899"}],c=[{code:"training",name:"Antrenament",description:"Sesiune de învățare cu explicații detaliate și experiență ghidată. Perfect pentru dobândirea de cunoștințe noi și înțelegerea conceptelor complexe pas cu pas.",color:"#3b82f6"},{code:"practice",name:"Practică",description:"Sesiune de consolidare pentru solidificarea cunoștințelor deja învățate. Ajută la consolidarea înțelegerii prin repetiție și aplicarea conceptelor învățate.",color:"#10b981"},{code:"simulation",name:"Simulare",description:"Mediu de testare simulat care reproduce condițiile reale de examen. Oferă o experiență de practică realistă cu timp și presiune autentice.",color:"#f59e0b"},{code:"quiz",name:"Quiz",description:"Verificare rapidă a cunoștințelor cu feedback imediat. Sesiuni scurte și focalizate pentru a evalua înțelegerea actuală și a identifica domeniile de îmbunătățit.",color:"#8b5cf6"},{code:"challenge",name:"Provocare",description:"Întrebări competitive sau dificile concepute pentru a testa limitele. Sesiuni avansate care îți împing limitele cunoștințelor și abilitățile de gândire critică.",color:"#ef4444"},{code:"tournament",name:"Turneu",description:"Sesiune competitivă multiplayer cu clasamente și premii. Concurează cu alți jucători în timp real pentru poziții în clasament și recompense.",color:"#f59e0b"},{code:"review",name:"Recapitulare",description:"Sesiune pentru revizuirea întrebărilor răspunse anterior și greșelilor. Practică focalizată pe domeniile care necesită îmbunătățire pe baza performanțelor anterioare.",color:"#6b7280"},{code:"diagnostic",name:"Diagnostic",description:"Evaluare inițială pentru identificarea lacunelor de cunoștințe și nivelurilor de competențe. Evaluare cuprinzătoare pentru crearea unei căi de învățare personalizate.",color:"#06b6d4"},{code:"speed_test",name:"Test de Viteză",description:"Întrebări rapide sub presiunea timpului, axate pe viteză și acuratețe. Dezvoltă gândirea rapidă și abilitățile de luare a deciziilor sub constrângeri de timp.",color:"#ec4899"}];export{c as SESSION_TYPES_RO,t as SESSION_TYPES_FR,s as SESSION_TYPES_EN,n as ESessionType,o as EAnswerState};
+
+//# debugId=5E9540D7660497F164756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["src/types.ts", "src/constants.ts"],
+  "sourcesContent": [
+    "import type { IBase } from \"@ooneex/types\";\n\nexport interface ILevel extends IBase {\n  name: string;\n  code: string;\n  color: string;\n}\n\nexport enum ESessionType {\n  /** Learning-focused session with detailed explanations and guided experience */\n  TRAINING = \"training\",\n  /** Reinforcement session for solidifying already learned knowledge */\n  PRACTICE = \"practice\",\n  /** Mock test environment simulating real exam conditions */\n  SIMULATION = \"simulation\",\n  /** Quick knowledge check with immediate feedback */\n  QUIZ = \"quiz\",\n  /** Competitive or difficult questions designed to test limits */\n  CHALLENGE = \"challenge\",\n  /** Multiplayer competitive session with rankings and prizes */\n  TOURNAMENT = \"tournament\",\n  /** Session for revisiting previously answered questions and mistakes */\n  REVIEW = \"review\",\n  /** Initial assessment to identify knowledge gaps and skill levels */\n  DIAGNOSTIC = \"diagnostic\",\n  /** Time-pressured rapid-fire questions focusing on speed and accuracy */\n  SPEED_TEST = \"speed_test\",\n}\n\nexport enum EAnswerState {\n  CORRECT = \"correct\",\n  INCORRECT = \"incorrect\",\n}\n",
+    "import { ESessionType } from \"./types\";\n\ntype SessionTypeItem = {\n  readonly code: ESessionType;\n  readonly name: string;\n  readonly description: string;\n  readonly color: string;\n};\n\nexport const SESSION_TYPES_EN: readonly SessionTypeItem[] = [\n  {\n    code: ESessionType.TRAINING,\n    name: \"Training\",\n    description:\n      \"Learning-focused session with detailed explanations and guided experience. Perfect for acquiring new knowledge and understanding complex concepts step by step.\",\n    color: \"#3b82f6\",\n  },\n  {\n    code: ESessionType.PRACTICE,\n    name: \"Practice\",\n    description:\n      \"Reinforcement session for solidifying already learned knowledge. Helps strengthen understanding through repetition and application of learned concepts.\",\n    color: \"#10b981\",\n  },\n  {\n    code: ESessionType.SIMULATION,\n    name: \"Simulation\",\n    description:\n      \"Mock test environment simulating real exam conditions. Provides realistic practice experience with authentic timing and pressure conditions.\",\n    color: \"#f59e0b\",\n  },\n  {\n    code: ESessionType.QUIZ,\n    name: \"Quiz\",\n    description:\n      \"Quick knowledge check with immediate feedback. Short and focused sessions to assess current understanding and identify areas for improvement.\",\n    color: \"#8b5cf6\",\n  },\n  {\n    code: ESessionType.CHALLENGE,\n    name: \"Challenge\",\n    description:\n      \"Competitive or difficult questions designed to test limits. Advanced sessions that push your knowledge boundaries and critical thinking skills.\",\n    color: \"#ef4444\",\n  },\n  {\n    code: ESessionType.TOURNAMENT,\n    name: \"Tournament\",\n    description:\n      \"Multiplayer competitive session with rankings and prizes. Compete against other players in real-time for leaderboard positions and rewards.\",\n    color: \"#f59e0b\",\n  },\n  {\n    code: ESessionType.REVIEW,\n    name: \"Review\",\n    description:\n      \"Session for revisiting previously answered questions and mistakes. Focused practice on areas where improvement is needed based on past performance.\",\n    color: \"#6b7280\",\n  },\n  {\n    code: ESessionType.DIAGNOSTIC,\n    name: \"Diagnostic\",\n    description:\n      \"Initial assessment to identify knowledge gaps and skill levels. Comprehensive evaluation to create a personalized learning path.\",\n    color: \"#06b6d4\",\n  },\n  {\n    code: ESessionType.SPEED_TEST,\n    name: \"Speed Test\",\n    description:\n      \"Time-pressured rapid-fire questions focusing on speed and accuracy. Develops quick thinking and decision-making skills under time constraints.\",\n    color: \"#ec4899\",\n  },\n] as const;\n\nexport const SESSION_TYPES_FR: readonly SessionTypeItem[] = [\n  {\n    code: ESessionType.TRAINING,\n    name: \"Formation\",\n    description:\n      \"Session d'apprentissage avec explications détaillées et expérience guidée. Parfait pour acquérir de nouvelles connaissances et comprendre des concepts complexes étape par étape.\",\n    color: \"#3b82f6\",\n  },\n  {\n    code: ESessionType.PRACTICE,\n    name: \"Pratique\",\n    description:\n      \"Session de renforcement pour consolider les connaissances déjà apprises. Aide à renforcer la compréhension par la répétition et l'application des concepts appris.\",\n    color: \"#10b981\",\n  },\n  {\n    code: ESessionType.SIMULATION,\n    name: \"Simulation\",\n    description:\n      \"Environnement d'examen simulé reproduisant les conditions réelles d'examen. Offre une expérience de pratique réaliste avec un timing et une pression authentiques.\",\n    color: \"#f59e0b\",\n  },\n  {\n    code: ESessionType.QUIZ,\n    name: \"Quiz\",\n    description:\n      \"Contrôle rapide des connaissances avec feedback immédiat. Sessions courtes et ciblées pour évaluer la compréhension actuelle et identifier les domaines à améliorer.\",\n    color: \"#8b5cf6\",\n  },\n  {\n    code: ESessionType.CHALLENGE,\n    name: \"Défi\",\n    description:\n      \"Questions compétitives ou difficiles conçues pour tester les limites. Sessions avancées qui repoussent vos limites de connaissances et vos compétences de pensée critique.\",\n    color: \"#ef4444\",\n  },\n  {\n    code: ESessionType.TOURNAMENT,\n    name: \"Tournoi\",\n    description:\n      \"Session compétitive multijoueur avec classements et prix. Affrontez d'autres joueurs en temps réel pour des positions au classement et des récompenses.\",\n    color: \"#f59e0b\",\n  },\n  {\n    code: ESessionType.REVIEW,\n    name: \"Révision\",\n    description:\n      \"Session pour revoir les questions précédemment répondues et les erreurs. Pratique ciblée sur les domaines nécessitant une amélioration basée sur les performances passées.\",\n    color: \"#6b7280\",\n  },\n  {\n    code: ESessionType.DIAGNOSTIC,\n    name: \"Diagnostic\",\n    description:\n      \"Évaluation initiale pour identifier les lacunes de connaissances et les niveaux de compétences. Évaluation complète pour créer un parcours d'apprentissage personnalisé.\",\n    color: \"#06b6d4\",\n  },\n  {\n    code: ESessionType.SPEED_TEST,\n    name: \"Test de Vitesse\",\n    description:\n      \"Questions rapides sous pression temporelle axées sur la vitesse et la précision. Développe la pensée rapide et les compétences de prise de décision sous contraintes de temps.\",\n    color: \"#ec4899\",\n  },\n] as const;\n\nexport const SESSION_TYPES_RO: readonly SessionTypeItem[] = [\n  {\n    code: ESessionType.TRAINING,\n    name: \"Antrenament\",\n    description:\n      \"Sesiune de învățare cu explicații detaliate și experiență ghidată. Perfect pentru dobândirea de cunoștințe noi și înțelegerea conceptelor complexe pas cu pas.\",\n    color: \"#3b82f6\",\n  },\n  {\n    code: ESessionType.PRACTICE,\n    name: \"Practică\",\n    description:\n      \"Sesiune de consolidare pentru solidificarea cunoștințelor deja învățate. Ajută la consolidarea înțelegerii prin repetiție și aplicarea conceptelor învățate.\",\n    color: \"#10b981\",\n  },\n  {\n    code: ESessionType.SIMULATION,\n    name: \"Simulare\",\n    description:\n      \"Mediu de testare simulat care reproduce condițiile reale de examen. Oferă o experiență de practică realistă cu timp și presiune autentice.\",\n    color: \"#f59e0b\",\n  },\n  {\n    code: ESessionType.QUIZ,\n    name: \"Quiz\",\n    description:\n      \"Verificare rapidă a cunoștințelor cu feedback imediat. Sesiuni scurte și focalizate pentru a evalua înțelegerea actuală și a identifica domeniile de îmbunătățit.\",\n    color: \"#8b5cf6\",\n  },\n  {\n    code: ESessionType.CHALLENGE,\n    name: \"Provocare\",\n    description:\n      \"Întrebări competitive sau dificile concepute pentru a testa limitele. Sesiuni avansate care îți împing limitele cunoștințelor și abilitățile de gândire critică.\",\n    color: \"#ef4444\",\n  },\n  {\n    code: ESessionType.TOURNAMENT,\n    name: \"Turneu\",\n    description:\n      \"Sesiune competitivă multiplayer cu clasamente și premii. Concurează cu alți jucători în timp real pentru poziții în clasament și recompense.\",\n    color: \"#f59e0b\",\n  },\n  {\n    code: ESessionType.REVIEW,\n    name: \"Recapitulare\",\n    description:\n      \"Sesiune pentru revizuirea întrebărilor răspunse anterior și greșelilor. Practică focalizată pe domeniile care necesită îmbunătățire pe baza performanțelor anterioare.\",\n    color: \"#6b7280\",\n  },\n  {\n    code: ESessionType.DIAGNOSTIC,\n    name: \"Diagnostic\",\n    description:\n      \"Evaluare inițială pentru identificarea lacunelor de cunoștințe și nivelurilor de competențe. Evaluare cuprinzătoare pentru crearea unei căi de învățare personalizate.\",\n    color: \"#06b6d4\",\n  },\n  {\n    code: ESessionType.SPEED_TEST,\n    name: \"Test de Viteză\",\n    description:\n      \"Întrebări rapide sub presiunea timpului, axate pe viteză și acuratețe. Dezvoltă gândirea rapidă și abilitățile de luare a deciziilor sub constrângeri de timp.\",\n    color: \"#ec4899\",\n  },\n] as const;\n"
+  ],
+  "mappings": "AAQO,IAAK,GAAL,CAAK,IAAL,CAEL,WAAW,WAEX,WAAW,WAEX,aAAa,aAEb,OAAO,OAEP,YAAY,YAEZ,aAAa,aAEb,SAAS,SAET,aAAa,aAEb,aAAa,eAlBH,QAqBL,IAAK,GAAL,CAAK,IAAL,CACL,UAAU,UACV,YAAY,cAFF,QCpBL,IAAM,EAA+C,CAC1D,CACE,gBACA,KAAM,WACN,YACE,kKACF,MAAO,SACT,EACA,CACE,gBACA,KAAM,WACN,YACE,0JACF,MAAO,SACT,EACA,CACE,kBACA,KAAM,aACN,YACE,+IACF,MAAO,SACT,EACA,CACE,YACA,KAAM,OACN,YACE,gJACF,MAAO,SACT,EACA,CACE,iBACA,KAAM,YACN,YACE,kJACF,MAAO,SACT,EACA,CACE,kBACA,KAAM,aACN,YACE,8IACF,MAAO,SACT,EACA,CACE,cACA,KAAM,SACN,YACE,sJACF,MAAO,SACT,EACA,CACE,kBACA,KAAM,aACN,YACE,mIACF,MAAO,SACT,EACA,CACE,kBACA,KAAM,aACN,YACE,iJACF,MAAO,SACT,CACF,EAEa,EAA+C,CAC1D,CACE,gBACA,KAAM,YACN,YACE,oLACF,MAAO,SACT,EACA,CACE,gBACA,KAAM,WACN,YACE,qKACF,MAAO,SACT,EACA,CACE,kBACA,KAAM,aACN,YACE,qKACF,MAAO,SACT,EACA,CACE,YACA,KAAM,OACN,YACE,uKACF,MAAO,SACT,EACA,CACE,iBACA,KAAM,OACN,YACE,6KACF,MAAO,SACT,EACA,CACE,kBACA,KAAM,UACN,YACE,0JACF,MAAO,SACT,EACA,CACE,cACA,KAAM,WACN,YACE,6KACF,MAAO,SACT,EACA,CACE,kBACA,KAAM,aACN,YACE,2KACF,MAAO,SACT,EACA,CACE,kBACA,KAAM,kBACN,YACE,iLACF,MAAO,SACT,CACF,EAEa,EAA+C,CAC1D,CACE,gBACA,KAAM,cACN,YACE,iKACF,MAAO,SACT,EACA,CACE,gBACA,KAAM,WACN,YACE,+JACF,MAAO,SACT,EACA,CACE,kBACA,KAAM,WACN,YACE,6IACF,MAAO,SACT,EACA,CACE,YACA,KAAM,OACN,YACE,oKACF,MAAO,SACT,EACA,CACE,iBACA,KAAM,YACN,YACE,mKACF,MAAO,SACT,EACA,CACE,kBACA,KAAM,SACN,YACE,+IACF,MAAO,SACT,EACA,CACE,cACA,KAAM,eACN,YACE,yKACF,MAAO,SACT,EACA,CACE,kBACA,KAAM,aACN,YACE,yKACF,MAAO,SACT,EACA,CACE,kBACA,KAAM,iBACN,YACE,iKACF,MAAO,SACT,CACF",
+  "debugId": "5E9540D7660497F164756E2164756E21",
+  "names": []
+}

package/dist/mcq/index.d.ts

@@ -0,0 +1,98 @@
+import { IImage } from "@ooneex/image";
+import { IStatus } from "@ooneex/status";
+import { ITag } from "@ooneex/tag";
+import { IBase as IBase2, IStat } from "@ooneex/types";
+import { IBase } from "@ooneex/types";
+interface ILevel extends IBase {
+	name: string;
+	code: string;
+	color: string;
+}
+declare enum ESessionType {
+	/** Learning-focused session with detailed explanations and guided experience */
+	TRAINING = "training",
+	/** Reinforcement session for solidifying already learned knowledge */
+	PRACTICE = "practice",
+	/** Mock test environment simulating real exam conditions */
+	SIMULATION = "simulation",
+	/** Quick knowledge check with immediate feedback */
+	QUIZ = "quiz",
+	/** Competitive or difficult questions designed to test limits */
+	CHALLENGE = "challenge",
+	/** Multiplayer competitive session with rankings and prizes */
+	TOURNAMENT = "tournament",
+	/** Session for revisiting previously answered questions and mistakes */
+	REVIEW = "review",
+	/** Initial assessment to identify knowledge gaps and skill levels */
+	DIAGNOSTIC = "diagnostic",
+	/** Time-pressured rapid-fire questions focusing on speed and accuracy */
+	SPEED_TEST = "speed_test"
+}
+declare enum EAnswerState {
+	CORRECT = "correct",
+	INCORRECT = "incorrect"
+}
+declare enum EMcqQuestionChoiceLetter {
+	A = "A",
+	B = "B",
+	C = "C",
+	D = "D",
+	E = "E",
+	F = "F",
+	G = "G",
+	H = "H",
+	I = "I",
+	J = "J"
+}
+declare enum EMcqSessionStatus {
+	DRAFT = "draft",
+	STARTED = "started",
+	PAUSED = "paused",
+	COMPLETED = "completed"
+}
+interface IMcqQuestionChoice extends IBase2 {
+	letter: EMcqQuestionChoiceLetter;
+	text: string;
+	isCorrect: boolean;
+	explanation?: string;
+	question: IMcqQuestion;
+}
+interface IMcqQuestion extends IBase2 {
+	questionNumber: number;
+	text: string;
+	choices: IMcqQuestionChoice[];
+	context?: string;
+	contextId?: string;
+	stat?: IStat;
+	status?: IStatus;
+	image?: IImage;
+	tags?: ITag[];
+}
+interface IMcqSession extends IBase2 {
+	name: string;
+	totalQuestions: number;
+	answeredCount: number;
+	correctCount: number;
+	incorrectCount: number;
+	timing: number;
+	questions: IMcqQuestion[];
+	status: EMcqSessionStatus;
+	score: number;
+	startedAt?: Date | null;
+	pausedAt?: Date | null;
+	resumedAt?: Date | null;
+	completedAt?: Date | null;
+	type: ESessionType;
+	level: ILevel;
+}
+interface IMcqSessionQuestion extends IBase2 {
+	session: IMcqSession;
+	question: IMcqQuestion;
+	questionNumber: number;
+	selectedChoices: IMcqQuestionChoice[];
+	context?: string;
+	contextId?: string;
+	state: EAnswerState;
+	score: number;
+}
+export { IMcqSessionQuestion, IMcqSession, IMcqQuestionChoice, IMcqQuestion, EMcqSessionStatus, EMcqQuestionChoiceLetter };

package/dist/mcq/index.js

@@ -0,0 +1,3 @@
+var n;((e)=>{e.A="A";e.B="B";e.C="C";e.D="D";e.E="E";e.F="F";e.G="G";e.H="H";e.I="I";e.J="J"})(n||={});var s;((t)=>{t.DRAFT="draft";t.STARTED="started";t.PAUSED="paused";t.COMPLETED="completed"})(s||={});export{s as EMcqSessionStatus,n as EMcqQuestionChoiceLetter};
+
+//# debugId=EA8EAD6A5D8BC75D64756E2164756E21

package/dist/mcq/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["src/mcq/types.ts"],
+  "sourcesContent": [
+    "import type { IImage } from \"@ooneex/image\";\nimport type { IStatus } from \"@ooneex/status\";\nimport type { ITag } from \"@ooneex/tag\";\nimport type { IBase, IStat } from \"@ooneex/types\";\nimport type { EAnswerState, ESessionType, ILevel } from \"@/types\";\n\nexport enum EMcqQuestionChoiceLetter {\n  A = \"A\",\n  B = \"B\",\n  C = \"C\",\n  D = \"D\",\n  E = \"E\",\n  F = \"F\",\n  G = \"G\",\n  H = \"H\",\n  I = \"I\",\n  J = \"J\",\n}\n\nexport enum EMcqSessionStatus {\n  DRAFT = \"draft\",\n  STARTED = \"started\",\n  PAUSED = \"paused\",\n  COMPLETED = \"completed\",\n}\n\nexport interface IMcqQuestionChoice extends IBase {\n  letter: EMcqQuestionChoiceLetter;\n  text: string;\n  isCorrect: boolean;\n  explanation?: string;\n  question: IMcqQuestion;\n}\n\nexport interface IMcqQuestion extends IBase {\n  questionNumber: number;\n  text: string;\n  choices: IMcqQuestionChoice[];\n  context?: string;\n  contextId?: string;\n  stat?: IStat;\n  status?: IStatus;\n  image?: IImage;\n  tags?: ITag[];\n}\n\nexport interface IMcqSession extends IBase {\n  name: string;\n  totalQuestions: number;\n  answeredCount: number;\n  correctCount: number;\n  incorrectCount: number;\n  timing: number;\n  questions: IMcqQuestion[];\n  status: EMcqSessionStatus;\n  score: number;\n  startedAt?: Date | null;\n  pausedAt?: Date | null;\n  resumedAt?: Date | null;\n  completedAt?: Date | null;\n  type: ESessionType;\n  level: ILevel;\n}\n\nexport interface IMcqSessionQuestion extends IBase {\n  session: IMcqSession;\n  question: IMcqQuestion;\n  questionNumber: number;\n  selectedChoices: IMcqQuestionChoice[];\n  context?: string;\n  contextId?: string;\n  state: EAnswerState;\n  score: number;\n}\n"
+  ],
+  "mappings": "AAMO,IAAK,GAAL,CAAK,IAAL,CACL,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,MAVM,QAaL,IAAK,GAAL,CAAK,IAAL,CACL,QAAQ,QACR,UAAU,UACV,SAAS,SACT,YAAY,cAJF",
+  "debugId": "EA8EAD6A5D8BC75D64756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@ooneex/gamification",
+  "description": "",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./mcq": {
+      "import": {
+        "types": "./dist/mcq/index.d.ts",
+        "default": "./dist/mcq/index.js"
+      }
+    },
+    "./flashcard": {
+      "import": {
+        "types": "./dist/flashcard/index.d.ts",
+        "default": "./dist/flashcard/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "bunup",
+    "lint": "tsgo --noEmit && bunx biome lint",
+    "publish:prod": "bun publish --tolerate-republish --access public",
+    "publish:pack": "bun pm pack --destination ./dist",
+    "publish:dry": "bun publish --dry-run"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@ooneex/image": "0.0.1",
+    "@ooneex/status": "0.0.1",
+    "@ooneex/tag": "0.0.1",
+    "@ooneex/types": "0.0.1"
+  },
+  "peerDependencies": {}
+}