@quizpot/quizcore 0.0.1 → 0.0.3

package/README.md

@@ -1,9 +1,3 @@
 # Quizcore
 
-Core library for Quizpot
-
-## Installation
-
-```bash
-npm install git+https://github.com/quizpot/quizcore.git
-```
+Core library for Quizpot

package/dist/index.cjs

@@ -0,0 +1,582 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let zod = require("zod");
+zod = __toESM(zod);
+//#region src/events/client/host/kick-player.ts
+const createKickPlayerEvent = (playerId) => ({
+	type: "KICK_PLAYER",
+	payload: { playerId }
+});
+//#endregion
+//#region src/events/client/host/next-step.ts
+const createNextStepEvent = () => ({ type: "NEXT_STEP" });
+//#endregion
+//#region src/events/client/host/start-lobby.ts
+const createStartLobbyEvent = () => ({
+	type: "START_LOBBY",
+	payload: {}
+});
+//#endregion
+//#region src/events/client/player/submit-answer.ts
+const createSubmitAnswerEvent = (submission) => ({
+	type: "SUBMIT_ANSWER",
+	payload: { submission }
+});
+//#endregion
+//#region src/events/server/lobby-deleted.ts
+const createLobbyDeletedEvent = (reason) => ({
+	type: "LOBBY_DELETED",
+	payload: { reason }
+});
+//#endregion
+//#region src/events/server/lobby-joined.ts
+const createLobbyJoinedEvent = (lobby, me, isHost) => ({
+	type: "LOBBY_JOINED",
+	payload: {
+		lobby: {
+			code: lobby.code,
+			quizInfo: lobby.quizInfo,
+			status: lobby.status,
+			timeoutStartedAt: lobby.timeoutStartedAt,
+			duration: lobby.duration,
+			currentStep: lobby.currentStep,
+			settings: lobby.settings
+		},
+		me,
+		players: isHost ? lobby.players : void 0,
+		currentAnswers: isHost ? lobby.currentAnswers : void 0,
+		answers: isHost ? lobby.answers : void 0
+	}
+});
+//#endregion
+//#region src/events/server/lobby-status-update.ts
+const createLobbyStatusUpdateEvent = (payload) => ({
+	type: "LOBBY_STATUS_UPDATE",
+	payload
+});
+//#endregion
+//#region src/events/server/player-answer-result.ts
+const createPlayerAnswerResultEvent = (isCorrect, pointsAwarded, score, streak) => ({
+	type: "PLAYER_ANSWER_RESULT",
+	payload: {
+		isCorrect,
+		pointsAwarded,
+		score,
+		streak
+	}
+});
+//#endregion
+//#region src/events/server/player-joined.ts
+const createPlayerJoinedEvent = (player) => ({
+	type: "PLAYER_JOINED",
+	payload: { player }
+});
+//#endregion
+//#region src/events/server/player-kicked.ts
+const createPlayerKickedEvent = () => ({
+	type: "PLAYER_KICKED",
+	payload: {}
+});
+//#endregion
+//#region src/events/server/player-left.ts
+const createPlayerLeftEvent = (player) => ({
+	type: "PLAYER_LEFT",
+	payload: { player }
+});
+//#endregion
+//#region src/events/server/player-update.ts
+const createPlayerUpdateEvent = (player) => ({
+	type: "PLAYER_UPDATE",
+	payload: { player }
+});
+//#endregion
+//#region src/events/server/update-lobby-answers.ts
+const createUpdateLobbyAnswersEvent = (count) => ({
+	type: "UPDATE_LOBBY_ANSWERS",
+	payload: { count }
+});
+//#endregion
+//#region src/types/lobby.ts
+let LobbyStatus = /* @__PURE__ */ function(LobbyStatus) {
+	LobbyStatus["waiting"] = "waiting";
+	LobbyStatus["slide"] = "slide";
+	LobbyStatus["question"] = "question";
+	LobbyStatus["answer"] = "answer";
+	LobbyStatus["answers"] = "answers";
+	LobbyStatus["score"] = "score";
+	LobbyStatus["end"] = "end";
+	return LobbyStatus;
+}({});
+//#endregion
+//#region src/util/guards.ts
+const isQuestion = (step) => {
+	return step.type === "question";
+};
+const isSlide = (step) => {
+	return step.type === "slide";
+};
+const isMultipleChoice = (data) => {
+	return data.type === "multiple-choice";
+};
+const isTrueFalse = (data) => {
+	return data.type === "true-false";
+};
+const isShortAnswer = (data) => {
+	return data.type === "short-answer";
+};
+//#endregion
+//#region src/util/score.ts
+const BASE_SCORE = 500;
+const TIME_BONUS_MAX = 500;
+const calculateScore = (player, question, answer, quiz) => {
+	if (!answer.isCorrect) return {
+		newScore: player.score,
+		pointsAwarded: 0
+	};
+	const pointMultiplier = {
+		noPoints: 0,
+		normalPoints: 1,
+		doublePoints: 2
+	}[question.points] ?? 1;
+	if (pointMultiplier === 0) return {
+		newScore: player.score,
+		pointsAwarded: 0
+	};
+	let timeBonus = 0;
+	if (question.timeLimit > 0) {
+		const timeLimitMs = question.timeLimit * 1e3;
+		timeBonus = TIME_BONUS_MAX * (1 - Math.max(0, Math.min(answer.timeTaken, timeLimitMs)) / timeLimitMs);
+	}
+	let questionScore = (BASE_SCORE + timeBonus) * pointMultiplier;
+	if (player.streak >= 2) {
+		const totalQuestions = quiz.steps.filter((s) => s.type === "question").length;
+		const dynamicCap = Math.min(1.2 + Math.max(0, totalQuestions - 5) * .02, 1.5);
+		const streakMultiplier = Math.min(1 + (player.streak - 1) * .05, dynamicCap);
+		questionScore *= streakMultiplier;
+	}
+	const finalPoints = Math.trunc(questionScore);
+	return {
+		newScore: player.score + finalPoints,
+		pointsAwarded: finalPoints
+	};
+};
+//#endregion
+//#region src/util/validator.ts
+const isCorrect = (question, submission) => {
+	if (isMultipleChoice(question) && submission.type === "multiple-choice") {
+		if (question.matchAll) {
+			const correctIndices = question.choices.map((c, i) => c.correct ? i : -1).filter((i) => i !== -1);
+			return submission.choices.length === correctIndices.length && submission.choices.every((index) => correctIndices.includes(index));
+		}
+		if (submission.choices.length === 0) return false;
+		return submission.choices.every((index) => {
+			const choice = question.choices[index];
+			return choice ? choice.correct : false;
+		});
+	}
+	if (isTrueFalse(question) && submission.type === "true-false") return question.answer === submission.answer;
+	if (isShortAnswer(question) && submission.type === "short-answer") {
+		const playerAns = submission.answer.trim().toLowerCase();
+		return question.answers.some((ans) => ans.trim().toLowerCase() === playerAns);
+	}
+	return false;
+};
+//#endregion
+//#region src/managers/lobby-manager.ts
+const createLobby = (code, hostId, quiz) => ({
+	code,
+	host: hostId,
+	quiz,
+	quizInfo: {
+		title: quiz.title,
+		stepCount: quiz.steps.length,
+		theme: quiz.theme
+	},
+	players: [],
+	status: LobbyStatus.waiting,
+	currentStep: 0,
+	timeoutStartedAt: null,
+	duration: null,
+	currentAnswers: [],
+	answers: [],
+	settings: {
+		customNames: true,
+		displayOnDevice: true
+	}
+});
+const advanceLobby = (lobby) => {
+	const isLastStep = lobby.currentStep >= lobby.quiz.steps.length - 1;
+	switch (lobby.status) {
+		case LobbyStatus.waiting: return prepareStep(lobby, 0);
+		case LobbyStatus.slide:
+		case LobbyStatus.score: return isLastStep ? {
+			...lobby,
+			status: LobbyStatus.end
+		} : prepareStep(lobby, lobby.currentStep + 1);
+		case LobbyStatus.question: {
+			const step = lobby.quiz.steps[lobby.currentStep];
+			if (step.type !== "question") return lobby;
+			return {
+				...lobby,
+				status: LobbyStatus.answer,
+				timeoutStartedAt: Date.now(),
+				duration: step.data.timeLimit * 1e3,
+				currentAnswers: []
+			};
+		}
+		case LobbyStatus.answer: return {
+			...lobby,
+			status: LobbyStatus.answers
+		};
+		case LobbyStatus.answers: return {
+			...lobby,
+			status: LobbyStatus.score
+		};
+		default: return lobby;
+	}
+};
+const prepareStep = (lobby, index) => {
+	const step = lobby.quiz.steps[index];
+	if (!step) return lobby;
+	if (step.type === "slide") return {
+		...lobby,
+		status: LobbyStatus.slide,
+		currentStep: index
+	};
+	return {
+		...lobby,
+		status: LobbyStatus.question,
+		currentStep: index,
+		timeoutStartedAt: null,
+		duration: null,
+		currentAnswers: []
+	};
+};
+const handleSubmission = (lobby, playerId, submission) => {
+	if (lobby.status !== LobbyStatus.answer) return null;
+	const step = lobby.quiz.steps[lobby.currentStep];
+	if (!isQuestion(step)) return null;
+	const player = lobby.players.find((p) => p.id === playerId);
+	if (!player) return null;
+	if (lobby.currentAnswers.some((a) => a.playerId === playerId)) return null;
+	const correct = isCorrect(step.data, submission);
+	const answerObj = {
+		playerId,
+		submission,
+		timeTaken: Date.now() - (lobby.timeoutStartedAt ?? 0),
+		isCorrect: correct,
+		pointsAwarded: 0
+	};
+	const { newScore, pointsAwarded } = calculateScore(player, step.data, answerObj, lobby.quiz);
+	answerObj.pointsAwarded = pointsAwarded;
+	return {
+		nextLobby: {
+			...lobby,
+			players: lobby.players.map((p) => p.id === playerId ? {
+				...p,
+				score: newScore,
+				streak: correct ? p.streak + 1 : 0
+			} : p),
+			currentAnswers: [...lobby.currentAnswers, answerObj]
+		},
+		result: {
+			type: "PLAYER_ANSWER_RESULT",
+			payload: {
+				isCorrect: correct,
+				pointsAwarded,
+				score: newScore,
+				streak: correct ? player.streak + 1 : 0
+			}
+		}
+	};
+};
+//#endregion
+//#region src/types/questions/true-false.ts
+const TrueFalseQuestionSchema = BaseQuestionSchema.extend({
+	type: zod.default.literal("true-false"),
+	answer: zod.default.boolean(),
+	labels: zod.default.array(zod.default.string()).min(2).max(2)
+});
+const SafeTrueFalseQuestionSchema = TrueFalseQuestionSchema.omit({ answer: true });
+const TrueFalseQuestionAnswerSchema = zod.default.object({
+	type: zod.default.literal("true-false"),
+	answer: zod.default.boolean()
+});
+//#endregion
+//#region src/types/questions/short-answer.ts
+const ShortAnswerQuestionSchema = BaseQuestionSchema.extend({
+	type: zod.default.literal("short-answer"),
+	answers: zod.default.array(zod.default.string()).min(1)
+});
+const SafeShortAnswerQuestionSchema = ShortAnswerQuestionSchema.omit({ answers: true });
+const ShortAnswerQuestionAnswerSchema = zod.default.object({
+	type: zod.default.literal("short-answer"),
+	answer: zod.default.string()
+});
+//#endregion
+//#region src/types/question.ts
+const QuestionSchema = zod.default.discriminatedUnion("type", [
+	MultipleChoiceQuestionSchema,
+	TrueFalseQuestionSchema,
+	ShortAnswerQuestionSchema
+]);
+zod.default.discriminatedUnion("type", [
+	SafeMultipleChoiceQuestionSchema,
+	SafeTrueFalseQuestionSchema,
+	SafeShortAnswerQuestionSchema
+]);
+const QuestionPointsSchema = zod.default.enum([
+	"normalPoints",
+	"doublePoints",
+	"noPoints"
+]);
+const BaseQuestionSchema = zod.default.object({
+	question: zod.default.string().min(1),
+	imageHash: zod.default.hash("sha256", { error: "Invalid image hash" }).optional(),
+	displayTime: zod.default.number().min(1).max(60),
+	timeLimit: zod.default.number().min(1).max(180),
+	points: QuestionPointsSchema
+});
+//#endregion
+//#region src/types/questions/multiple-choice.ts
+const ChoiceSchema = zod.default.object({
+	text: zod.default.string(),
+	correct: zod.default.boolean()
+});
+const SafeChoiceSchema = ChoiceSchema.omit({ correct: true });
+const MultipleChoiceQuestionSchema = BaseQuestionSchema.extend({
+	type: zod.default.literal("multiple-choice"),
+	choices: zod.default.array(ChoiceSchema).min(2),
+	matchAll: zod.default.boolean()
+});
+const SafeMultipleChoiceQuestionSchema = MultipleChoiceQuestionSchema.omit({ choices: true }).extend({ choices: zod.default.array(SafeChoiceSchema).min(2) });
+const MultipleChoiceQuestionAnswerSchema = zod.default.object({
+	type: zod.default.literal("multiple-choice"),
+	choices: zod.default.array(zod.default.number()).min(1)
+});
+//#endregion
+//#region src/types/quiztheme.ts
+const QuizThemeSchema = zod.default.object({
+	color: zod.default.string().regex(/^#[0-9a-fA-F]{6}$/, { message: "Invalid color format. Must be a 7-character hex code (e.g., #RRGGBB)." }),
+	background: zod.default.hash("sha256", { error: "Invalid background hash" }).optional()
+});
+//#endregion
+//#region src/types/slides/titleSlide.ts
+const TitleSlideLayoutSchema = zod.default.object({
+	slideType: zod.default.literal("title"),
+	title: zod.default.string(),
+	subtitle: zod.default.string().optional()
+});
+//#endregion
+//#region src/types/slides/titleImageTextSlide.ts
+const TitleImageTextSlideLayoutSchema = zod.default.object({
+	slideType: zod.default.literal("titleImageText"),
+	title: zod.default.string(),
+	imageHash: zod.default.hash("sha256", { error: "Invalid image hash" }).optional(),
+	text: zod.default.string()
+});
+//#endregion
+//#region src/types/slides/comparison.ts
+const ComparisonSlideLayoutSchema = zod.default.object({
+	slideType: zod.default.literal("comparison"),
+	title: zod.default.string(),
+	left: zod.default.string(),
+	right: zod.default.string()
+});
+//#endregion
+//#region src/types/slide.ts
+const SlideSchema = zod.default.discriminatedUnion("slideType", [
+	TitleSlideLayoutSchema,
+	TitleImageTextSlideLayoutSchema,
+	ComparisonSlideLayoutSchema
+]);
+//#endregion
+//#region src/types/quizstep.ts
+const QuizStepSchema = zod.default.discriminatedUnion("type", [zod.default.object({
+	type: zod.default.literal("question"),
+	data: QuestionSchema
+}), zod.default.object({
+	type: zod.default.literal("slide"),
+	data: SlideSchema
+})]);
+//#endregion
+//#region src/types/quizfile.ts
+const QuizFileSchema = zod.default.object({
+	id: zod.default.uuid(),
+	version: zod.default.literal(2),
+	title: zod.default.string().min(1, "Title must be atleast 1 character long").max(64, "Title can't be longer than 64 characters"),
+	description: zod.default.string().max(255, "Description can't be longer than 256 characters").optional(),
+	theme: QuizThemeSchema,
+	language: zod.default.string().length(2, "Language must be a 2-letter ISO 639-1 code"),
+	steps: zod.default.array(QuizStepSchema).min(1, "Quiz must have at least 1 step"),
+	images: zod.default.record(zod.default.hash("sha256", { error: "Invalid image hash" }), zod.default.string().refine((val) => {
+		return val.startsWith("http") || val.startsWith("data:image/");
+	}, "Image must be a valid URL or Base64 data string")),
+	updatedAt: zod.default.iso.datetime(),
+	createdAt: zod.default.iso.datetime()
+});
+//#endregion
+//#region src/util/names/animals.json
+var animals_default = [
+	"Dog",
+	"Cat",
+	"Rabbit",
+	"Lion",
+	"Tiger",
+	"Bear",
+	"Wolf",
+	"Fox",
+	"Panda",
+	"Elephant",
+	"Gorilla",
+	"Giraffe",
+	"Hippo",
+	"Rhino",
+	"Zebra",
+	"Crocodile",
+	"Alligator",
+	"Octopus",
+	"Butterfly",
+	"Bee",
+	"Ant"
+];
+//#endregion
+//#region src/util/names/additives.json
+var additives_default = [
+	"Funny",
+	"Happy",
+	"Sad",
+	"Angry",
+	"Scary",
+	"Serious",
+	"Cautious",
+	"Joyful",
+	"Broken",
+	"Smart",
+	"Shy",
+	"Silly",
+	"Lazy",
+	"Cheerful",
+	"Calm",
+	"Sleepy",
+	"Tired",
+	"Lonely",
+	"Crazy",
+	"Mad",
+	"Gentle"
+];
+//#endregion
+//#region src/util/names/colors.json
+var colors_default = [
+	"Red",
+	"Blue",
+	"Green",
+	"Yellow",
+	"Purple",
+	"Orange",
+	"Pink",
+	"Brown",
+	"Black",
+	"White",
+	"Gray",
+	"Cyan"
+];
+//#endregion
+//#region src/util/names/names.ts
+const generateName = () => {
+	const animal = animals_default[Math.floor(Math.random() * animals_default.length)];
+	const additive = additives_default[Math.floor(Math.random() * additives_default.length)];
+	return `${colors_default[Math.floor(Math.random() * colors_default.length)]}${additive}${animal}`;
+};
+const generateUniqueName = (players) => {
+	const maxPossible = animals_default.length * additives_default.length * colors_default.length;
+	if (players.length >= maxPossible) throw new Error("No unique names available");
+	const existingNames = new Set(players.map((p) => p.name));
+	for (let i = 0; i < 100; i++) {
+		const candidate = generateName();
+		if (!existingNames.has(candidate)) return candidate;
+	}
+	for (const c of colors_default) for (const ad of additives_default) for (const an of animals_default) {
+		const candidate = `${c}${ad}${an}`;
+		if (!existingNames.has(candidate)) return candidate;
+	}
+	throw new Error("No unique names available");
+};
+//#endregion
+//#region src/util/sanitizer.ts
+const sanitizeQuestion = (question) => {
+	if (isMultipleChoice(question)) return {
+		...question,
+		choices: question.choices.map(({ text }) => ({ text }))
+	};
+	if (isTrueFalse(question)) {
+		const { answer, ...sanitized } = question;
+		return sanitized;
+	}
+	if (isShortAnswer(question)) {
+		const { answers, ...sanitized } = question;
+		return sanitized;
+	}
+	throw new Error("Invalid question type");
+};
+//#endregion
+exports.ChoiceSchema = ChoiceSchema;
+exports.LobbyStatus = LobbyStatus;
+exports.MultipleChoiceQuestionAnswerSchema = MultipleChoiceQuestionAnswerSchema;
+exports.MultipleChoiceQuestionSchema = MultipleChoiceQuestionSchema;
+exports.QuizFileSchema = QuizFileSchema;
+exports.SafeChoiceSchema = SafeChoiceSchema;
+exports.SafeMultipleChoiceQuestionSchema = SafeMultipleChoiceQuestionSchema;
+exports.SafeShortAnswerQuestionSchema = SafeShortAnswerQuestionSchema;
+exports.SafeTrueFalseQuestionSchema = SafeTrueFalseQuestionSchema;
+exports.ShortAnswerQuestionAnswerSchema = ShortAnswerQuestionAnswerSchema;
+exports.ShortAnswerQuestionSchema = ShortAnswerQuestionSchema;
+exports.TrueFalseQuestionAnswerSchema = TrueFalseQuestionAnswerSchema;
+exports.TrueFalseQuestionSchema = TrueFalseQuestionSchema;
+exports.advanceLobby = advanceLobby;
+exports.calculateScore = calculateScore;
+exports.createKickPlayerEvent = createKickPlayerEvent;
+exports.createLobby = createLobby;
+exports.createLobbyDeletedEvent = createLobbyDeletedEvent;
+exports.createLobbyJoinedEvent = createLobbyJoinedEvent;
+exports.createLobbyStatusUpdateEvent = createLobbyStatusUpdateEvent;
+exports.createNextStepEvent = createNextStepEvent;
+exports.createPlayerAnswerResultEvent = createPlayerAnswerResultEvent;
+exports.createPlayerJoinedEvent = createPlayerJoinedEvent;
+exports.createPlayerKickedEvent = createPlayerKickedEvent;
+exports.createPlayerLeftEvent = createPlayerLeftEvent;
+exports.createPlayerUpdateEvent = createPlayerUpdateEvent;
+exports.createStartLobbyEvent = createStartLobbyEvent;
+exports.createSubmitAnswerEvent = createSubmitAnswerEvent;
+exports.createUpdateLobbyAnswersEvent = createUpdateLobbyAnswersEvent;
+exports.generateName = generateName;
+exports.generateUniqueName = generateUniqueName;
+exports.handleSubmission = handleSubmission;
+exports.isCorrect = isCorrect;
+exports.isMultipleChoice = isMultipleChoice;
+exports.isQuestion = isQuestion;
+exports.isShortAnswer = isShortAnswer;
+exports.isSlide = isSlide;
+exports.isTrueFalse = isTrueFalse;
+exports.sanitizeQuestion = sanitizeQuestion;