@quizpot/quizcore 0.0.1

package/dist/types/quizfile.d.ts

@@ -0,0 +1,79 @@
+import z from "zod";
+export type QuizFile = z.infer<typeof QuizFileSchema>;
+export declare const QuizFileSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    version: z.ZodLiteral<2>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    theme: z.ZodObject<{
+        color: z.ZodString;
+        background: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+    }, z.core.$strip>;
+    language: z.ZodString;
+    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"question">;
+        data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            question: z.ZodString;
+            imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+            displayTime: z.ZodNumber;
+            timeLimit: z.ZodNumber;
+            points: z.ZodEnum<{
+                normalPoints: "normalPoints";
+                doublePoints: "doublePoints";
+                noPoints: "noPoints";
+            }>;
+            type: z.ZodLiteral<"multiple-choice">;
+            choices: z.ZodArray<z.ZodObject<{
+                text: z.ZodString;
+                correct: z.ZodBoolean;
+            }, z.core.$strip>>;
+            matchAll: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            question: z.ZodString;
+            imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+            displayTime: z.ZodNumber;
+            timeLimit: z.ZodNumber;
+            points: z.ZodEnum<{
+                normalPoints: "normalPoints";
+                doublePoints: "doublePoints";
+                noPoints: "noPoints";
+            }>;
+            type: z.ZodLiteral<"true-false">;
+            answer: z.ZodBoolean;
+            labels: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            question: z.ZodString;
+            imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+            displayTime: z.ZodNumber;
+            timeLimit: z.ZodNumber;
+            points: z.ZodEnum<{
+                normalPoints: "normalPoints";
+                doublePoints: "doublePoints";
+                noPoints: "noPoints";
+            }>;
+            type: z.ZodLiteral<"short-answer">;
+            answers: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>], "type">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"slide">;
+        data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            slideType: z.ZodLiteral<"title">;
+            title: z.ZodString;
+            subtitle: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            slideType: z.ZodLiteral<"titleImageText">;
+            title: z.ZodString;
+            imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            slideType: z.ZodLiteral<"comparison">;
+            title: z.ZodString;
+            left: z.ZodString;
+            right: z.ZodString;
+        }, z.core.$strip>], "slideType">;
+    }, z.core.$strip>], "type">>;
+    images: z.ZodRecord<z.ZodCustomStringFormat<"sha256_hex">, z.ZodString>;
+    updatedAt: z.ZodISODateTime;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strip>;
+//# sourceMappingURL=quizfile.d.ts.map

package/dist/types/quizfile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quizfile.d.ts","sourceRoot":"","sources":["../../src/types/quizfile.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BzB,CAAC"}

package/dist/types/quizfile.js

@@ -0,0 +1,23 @@
+import z from "zod";
+import { QuizThemeSchema } from "./quiztheme";
+import { QuizStepSchema } from "./quizstep";
+export const QuizFileSchema = z.object({
+    id: z.uuid(),
+    version: z.literal(2),
+    title: z.string()
+        .min(1, "Title must be atleast 1 character long")
+        .max(64, "Title can't be longer than 64 characters"),
+    description: z.string()
+        .max(255, "Description can't be longer than 256 characters")
+        .optional(),
+    theme: QuizThemeSchema,
+    language: z.string()
+        .length(2, "Language must be a 2-letter ISO 639-1 code"),
+    steps: z.array(QuizStepSchema)
+        .min(1, "Quiz must have at least 1 step"),
+    images: z.record(z.hash("sha256", { error: "Invalid image hash" }), z.string().refine((val) => {
+        return val.startsWith("http") || val.startsWith("data:image/");
+    }, "Image must be a valid URL or Base64 data string")),
+    updatedAt: z.iso.datetime(),
+    createdAt: z.iso.datetime(),
+});

package/dist/types/quizstep.d.ts

@@ -0,0 +1,73 @@
+import z from "zod";
+import { Question } from "./question";
+import { Slide } from "./slide";
+export type QuizStep = {
+    type: "question";
+    data: Question;
+} | {
+    type: "slide";
+    data: Slide;
+};
+export declare const QuizStepSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"question">;
+    data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        question: z.ZodString;
+        imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+        displayTime: z.ZodNumber;
+        timeLimit: z.ZodNumber;
+        points: z.ZodEnum<{
+            normalPoints: "normalPoints";
+            doublePoints: "doublePoints";
+            noPoints: "noPoints";
+        }>;
+        type: z.ZodLiteral<"multiple-choice">;
+        choices: z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            correct: z.ZodBoolean;
+        }, z.core.$strip>>;
+        matchAll: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        question: z.ZodString;
+        imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+        displayTime: z.ZodNumber;
+        timeLimit: z.ZodNumber;
+        points: z.ZodEnum<{
+            normalPoints: "normalPoints";
+            doublePoints: "doublePoints";
+            noPoints: "noPoints";
+        }>;
+        type: z.ZodLiteral<"true-false">;
+        answer: z.ZodBoolean;
+        labels: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        question: z.ZodString;
+        imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+        displayTime: z.ZodNumber;
+        timeLimit: z.ZodNumber;
+        points: z.ZodEnum<{
+            normalPoints: "normalPoints";
+            doublePoints: "doublePoints";
+            noPoints: "noPoints";
+        }>;
+        type: z.ZodLiteral<"short-answer">;
+        answers: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"slide">;
+    data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        slideType: z.ZodLiteral<"title">;
+        title: z.ZodString;
+        subtitle: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        slideType: z.ZodLiteral<"titleImageText">;
+        title: z.ZodString;
+        imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        slideType: z.ZodLiteral<"comparison">;
+        title: z.ZodString;
+        left: z.ZodString;
+        right: z.ZodString;
+    }, z.core.$strip>], "slideType">;
+}, z.core.$strip>], "type">;
+//# sourceMappingURL=quizstep.d.ts.map

package/dist/types/quizstep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quizstep.d.ts","sourceRoot":"","sources":["../../src/types/quizstep.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,EAAE,QAAQ,EAAkB,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,KAAK,EAAe,MAAM,SAAS,CAAC;AAE7C,MAAM,MAAM,QAAQ,GAChB;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;CAChB,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,KAAK,CAAC;CACb,CAAC;AAEN,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAGzB,CAAC"}

package/dist/types/quizstep.js

@@ -0,0 +1,7 @@
+import z from "zod";
+import { QuestionSchema } from "./question";
+import { SlideSchema } from "./slide";
+export const QuizStepSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("question"), data: QuestionSchema }),
+    z.object({ type: z.literal("slide"), data: SlideSchema }),
+]);

package/dist/types/quiztheme.d.ts

@@ -0,0 +1,7 @@
+import z from "zod";
+export type QuizTheme = z.infer<typeof QuizThemeSchema>;
+export declare const QuizThemeSchema: z.ZodObject<{
+    color: z.ZodString;
+    background: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+}, z.core.$strip>;
+//# sourceMappingURL=quiztheme.d.ts.map

package/dist/types/quiztheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quiztheme.d.ts","sourceRoot":"","sources":["../../src/types/quiztheme.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,eAAe;;;iBAM1B,CAAC"}

package/dist/types/quiztheme.js

@@ -0,0 +1,5 @@
+import z from "zod";
+export const QuizThemeSchema = z.object({
+    color: z.string().regex(/^#[0-9a-fA-F]{6}$/, { message: 'Invalid color format. Must be a 7-character hex code (e.g., #RRGGBB).' }),
+    background: z.hash("sha256", { error: "Invalid background hash" }).optional(),
+});

package/dist/types/slide.d.ts

@@ -0,0 +1,18 @@
+import z from "zod";
+export type Slide = z.infer<typeof SlideSchema>;
+export declare const SlideSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    slideType: z.ZodLiteral<"title">;
+    title: z.ZodString;
+    subtitle: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    slideType: z.ZodLiteral<"titleImageText">;
+    title: z.ZodString;
+    imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    slideType: z.ZodLiteral<"comparison">;
+    title: z.ZodString;
+    left: z.ZodString;
+    right: z.ZodString;
+}, z.core.$strip>], "slideType">;
+//# sourceMappingURL=slide.d.ts.map

package/dist/types/slide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slide.d.ts","sourceRoot":"","sources":["../../src/types/slide.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAKpB,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEhD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;gCAItB,CAAC"}

package/dist/types/slide.js

@@ -0,0 +1,9 @@
+import z from "zod";
+import { TitleSlideLayoutSchema } from "./slides/titleSlide";
+import { TitleImageTextSlideLayoutSchema } from "./slides/titleImageTextSlide";
+import { ComparisonSlideLayoutSchema } from "./slides/comparison";
+export const SlideSchema = z.discriminatedUnion("slideType", [
+    TitleSlideLayoutSchema,
+    TitleImageTextSlideLayoutSchema,
+    ComparisonSlideLayoutSchema
+]);

package/dist/types/slides/comparison.d.ts

@@ -0,0 +1,9 @@
+import z from "zod";
+export declare const ComparisonSlideLayoutSchema: z.ZodObject<{
+    slideType: z.ZodLiteral<"comparison">;
+    title: z.ZodString;
+    left: z.ZodString;
+    right: z.ZodString;
+}, z.core.$strip>;
+export type ComparisonSlideLayout = z.infer<typeof ComparisonSlideLayoutSchema>;
+//# sourceMappingURL=comparison.d.ts.map

package/dist/types/slides/comparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparison.d.ts","sourceRoot":"","sources":["../../../src/types/slides/comparison.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,2BAA2B;;;;;iBAKtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/types/slides/comparison.js

@@ -0,0 +1,7 @@
+import z from "zod";
+export const ComparisonSlideLayoutSchema = z.object({
+    slideType: z.literal("comparison"),
+    title: z.string(),
+    left: z.string(),
+    right: z.string(),
+});

package/dist/types/slides/titleImageTextSlide.d.ts

@@ -0,0 +1,9 @@
+import z from "zod";
+export declare const TitleImageTextSlideLayoutSchema: z.ZodObject<{
+    slideType: z.ZodLiteral<"titleImageText">;
+    title: z.ZodString;
+    imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+    text: z.ZodString;
+}, z.core.$strip>;
+export type TitleImageTextSlideLayout = z.infer<typeof TitleImageTextSlideLayoutSchema>;
+//# sourceMappingURL=titleImageTextSlide.d.ts.map

package/dist/types/slides/titleImageTextSlide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"titleImageTextSlide.d.ts","sourceRoot":"","sources":["../../../src/types/slides/titleImageTextSlide.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,+BAA+B;;;;;iBAK1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/dist/types/slides/titleImageTextSlide.js

@@ -0,0 +1,7 @@
+import z from "zod";
+export const TitleImageTextSlideLayoutSchema = z.object({
+    slideType: z.literal("titleImageText"),
+    title: z.string(),
+    imageHash: z.hash("sha256", { error: "Invalid image hash" }).optional(),
+    text: z.string(),
+});

package/dist/types/slides/titleSlide.d.ts

@@ -0,0 +1,8 @@
+import z from "zod";
+export declare const TitleSlideLayoutSchema: z.ZodObject<{
+    slideType: z.ZodLiteral<"title">;
+    title: z.ZodString;
+    subtitle: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TitleSlideLayout = z.infer<typeof TitleSlideLayoutSchema>;
+//# sourceMappingURL=titleSlide.d.ts.map

package/dist/types/slides/titleSlide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"titleSlide.d.ts","sourceRoot":"","sources":["../../../src/types/slides/titleSlide.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/types/slides/titleSlide.js

@@ -0,0 +1,6 @@
+import z from "zod";
+export const TitleSlideLayoutSchema = z.object({
+    slideType: z.literal("title"),
+    title: z.string(),
+    subtitle: z.string().optional(),
+});

package/dist/util/guards.d.ts

@@ -0,0 +1,18 @@
+import { Question } from "../types/question";
+import { MultipleChoiceQuestion } from "../types/questions/multiple-choice";
+import { ShortAnswerQuestion } from "../types/questions/short-answer";
+import { TrueFalseQuestion } from "../types/questions/true-false";
+import { QuizStep } from "../types/quizstep";
+import { Slide } from "../types/slide";
+export declare const isQuestion: (step: QuizStep) => step is {
+    type: "question";
+    data: Question;
+};
+export declare const isSlide: (step: QuizStep) => step is {
+    type: "slide";
+    data: Slide;
+};
+export declare const isMultipleChoice: (data: Question) => data is MultipleChoiceQuestion;
+export declare const isTrueFalse: (data: Question) => data is TrueFalseQuestion;
+export declare const isShortAnswer: (data: Question) => data is ShortAnswerQuestion;
+//# sourceMappingURL=guards.d.ts.map

package/dist/util/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/util/guards.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEvC,eAAO,MAAM,UAAU,GAAI,MAAM,QAAQ,KAAG,IAAI,IAAI;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAErF,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,MAAM,QAAQ,KAAG,IAAI,IAAI;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAE5E,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,MAAM,QAAQ,KAAG,IAAI,IAAI,sBAEzD,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,MAAM,QAAQ,KAAG,IAAI,IAAI,iBAEpD,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,MAAM,QAAQ,KAAG,IAAI,IAAI,mBAEtD,CAAC"}

package/dist/util/guards.js

@@ -0,0 +1,15 @@
+export const isQuestion = (step) => {
+    return step.type === "question";
+};
+export const isSlide = (step) => {
+    return step.type === "slide";
+};
+export const isMultipleChoice = (data) => {
+    return data.type === "multiple-choice";
+};
+export const isTrueFalse = (data) => {
+    return data.type === "true-false";
+};
+export const isShortAnswer = (data) => {
+    return data.type === "short-answer";
+};

package/dist/util/names/additives.json

@@ -0,0 +1,23 @@
+[
+    "Funny",
+    "Happy",
+    "Sad",
+    "Angry",
+    "Scary",
+    "Serious",
+    "Cautious",
+    "Joyful",
+    "Broken",
+    "Smart",
+    "Shy",
+    "Silly",
+    "Lazy",
+    "Cheerful",
+    "Calm",
+    "Sleepy",
+    "Tired",
+    "Lonely",
+    "Crazy",
+    "Mad",
+    "Gentle"
+]

package/dist/util/names/animals.json

@@ -0,0 +1,23 @@
+[
+    "Dog",
+    "Cat",
+    "Rabbit",
+    "Lion",
+    "Tiger",
+    "Bear",
+    "Wolf",
+    "Fox",
+    "Panda",
+    "Elephant",
+    "Gorilla",
+    "Giraffe",
+    "Hippo",
+    "Rhino",
+    "Zebra",
+    "Crocodile",
+    "Alligator",
+    "Octopus",
+    "Butterfly",
+    "Bee",
+    "Ant"
+]

package/dist/util/names/colors.json

@@ -0,0 +1,14 @@
+[
+    "Red",
+    "Blue",
+    "Green",
+    "Yellow",
+    "Purple",
+    "Orange",
+    "Pink",
+    "Brown",
+    "Black",
+    "White",
+    "Gray",
+    "Cyan"
+]

package/dist/util/names/names.d.ts

@@ -0,0 +1,4 @@
+import { Player } from "../../types/lobby";
+export declare const generateName: () => string;
+export declare const generateUniqueName: (players: Player[]) => string;
+//# sourceMappingURL=names.d.ts.map

package/dist/util/names/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../../src/util/names/names.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,eAAO,MAAM,YAAY,QAAO,MAM/B,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,EAAE,KAAG,MAwBtD,CAAC"}

package/dist/util/names/names.js

@@ -0,0 +1,31 @@
+import animals from "./animals.json";
+import additives from "./additives.json";
+import colors from "./colors.json";
+export const generateName = () => {
+    const animal = animals[Math.floor(Math.random() * animals.length)];
+    const additive = additives[Math.floor(Math.random() * additives.length)];
+    const color = colors[Math.floor(Math.random() * colors.length)];
+    return `${color}${additive}${animal}`;
+};
+export const generateUniqueName = (players) => {
+    const maxPossible = animals.length * additives.length * colors.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) {
+        for (const ad of additives) {
+            for (const an of animals) {
+                const candidate = `${c}${ad}${an}`;
+                if (!existingNames.has(candidate))
+                    return candidate;
+            }
+        }
+    }
+    throw new Error("No unique names available"); // Fallback
+};

package/dist/util/sanitizer.d.ts

@@ -0,0 +1,3 @@
+import { Question, SafeQuestion } from "../types/question";
+export declare const sanitizeQuestion: (question: Question) => SafeQuestion;
+//# sourceMappingURL=sanitizer.d.ts.map

package/dist/util/sanitizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizer.d.ts","sourceRoot":"","sources":["../../src/util/sanitizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAG3D,eAAO,MAAM,gBAAgB,GAAI,UAAU,QAAQ,KAAG,YAmBrD,CAAC"}

package/dist/util/sanitizer.js

@@ -0,0 +1,18 @@
+import { isMultipleChoice, isShortAnswer, isTrueFalse } from "./guards";
+export 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");
+};

package/dist/util/score.d.ts

@@ -0,0 +1,11 @@
+import { Answer } from "./validator";
+import { QuizFile } from "../types/quizfile";
+import { Question } from "../types/question";
+export declare const calculateScore: (player: {
+    score: number;
+    streak: number;
+}, question: Question, answer: Answer, quiz: QuizFile) => {
+    newScore: number;
+    pointsAwarded: number;
+};
+//# sourceMappingURL=score.d.ts.map

package/dist/util/score.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"score.d.ts","sourceRoot":"","sources":["../../src/util/score.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAK7C,eAAO,MAAM,cAAc,GACzB,QAAQ;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACzC,UAAU,QAAQ,EAClB,QAAQ,MAAM,EACd,MAAM,QAAQ,KACb;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAmC3C,CAAC"}

package/dist/util/score.js

@@ -0,0 +1,33 @@
+const BASE_SCORE = 500;
+const TIME_BONUS_MAX = 500;
+export const calculateScore = (player, question, answer, quiz) => {
+    if (!answer.isCorrect)
+        return { newScore: player.score, pointsAwarded: 0 };
+    const multipliers = {
+        noPoints: 0,
+        normalPoints: 1,
+        doublePoints: 2,
+    };
+    const pointMultiplier = multipliers[question.points] ?? 1;
+    if (pointMultiplier === 0)
+        return { newScore: player.score, pointsAwarded: 0 };
+    let timeBonus = 0;
+    if (question.timeLimit > 0) {
+        const timeLimitMs = question.timeLimit * 1000;
+        const timeTaken = Math.max(0, Math.min(answer.timeTaken, timeLimitMs));
+        const timeRemainingRatio = 1 - (timeTaken / timeLimitMs);
+        timeBonus = TIME_BONUS_MAX * timeRemainingRatio;
+    }
+    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) * 0.02, 1.5);
+        const streakMultiplier = Math.min(1 + (player.streak - 1) * 0.05, dynamicCap);
+        questionScore *= streakMultiplier;
+    }
+    const finalPoints = Math.trunc(questionScore);
+    return {
+        newScore: player.score + finalPoints,
+        pointsAwarded: finalPoints
+    };
+};

package/dist/util/validator.d.ts

@@ -0,0 +1,14 @@
+import { ShortAnswerQuestionAnswer } from "../types/questions/short-answer";
+import { TrueFalseQuestionAnswer } from "../types/questions/true-false";
+import { MultipleChoiceQuestionAnswer } from "../types/questions/multiple-choice";
+import { Question } from "../types/question";
+export type SubmittedAnswer = MultipleChoiceQuestionAnswer | TrueFalseQuestionAnswer | ShortAnswerQuestionAnswer;
+export interface Answer {
+    playerId: string;
+    submission: SubmittedAnswer;
+    timeTaken: number;
+    isCorrect: boolean;
+    pointsAwarded: number;
+}
+export declare const isCorrect: (question: Question, submission: SubmittedAnswer) => boolean;
+//# sourceMappingURL=validator.d.ts.map

package/dist/util/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../src/util/validator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAC5E,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AAClF,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,MAAM,MAAM,eAAe,GACvB,4BAA4B,GAC5B,uBAAuB,GACvB,yBAAyB,CAAC;AAE9B,MAAM,WAAW,MAAM;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,eAAe,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,SAAS,GAAI,UAAU,QAAQ,EAAE,YAAY,eAAe,KAAG,OA+B3E,CAAC"}

package/dist/util/validator.js

@@ -0,0 +1,27 @@
+import { isMultipleChoice, isShortAnswer, isTrueFalse } from "../util/guards";
+;
+export 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;
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@quizpot/quizcore",
+  "version": "0.0.1",
+  "description": "Core library for Quizpot",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "watch": "tsc --watch",
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "zod": "^4.3.6"
+  }
+}