@quizpot/quizcore 0.0.1

package/dist/schemas/quizfile.d.ts

@@ -0,0 +1,87 @@
+import { z } from "zod";
+export declare const QuizFileSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodLiteral<2>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    theme: z.ZodObject<{
+        color: z.ZodString;
+        background: z.ZodOptional<z.ZodString>;
+    }, 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.ZodString>;
+            displayTime: z.ZodNumber;
+            timeLimit: z.ZodNumber;
+            points: z.ZodEnum<{
+                normalPoints: "normalPoints";
+                doublePoints: "doublePoints";
+                noPoints: "noPoints";
+            }>;
+            type: z.ZodLiteral<"multiple-choice">;
+            options: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                text: z.ZodString;
+                isCorrect: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            question: z.ZodString;
+            imageHash: z.ZodOptional<z.ZodString>;
+            displayTime: z.ZodNumber;
+            timeLimit: z.ZodNumber;
+            points: z.ZodEnum<{
+                normalPoints: "normalPoints";
+                doublePoints: "doublePoints";
+                noPoints: "noPoints";
+            }>;
+            type: z.ZodLiteral<"true-false">;
+            answer: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            question: z.ZodString;
+            imageHash: z.ZodOptional<z.ZodString>;
+            displayTime: z.ZodNumber;
+            timeLimit: z.ZodNumber;
+            points: z.ZodEnum<{
+                normalPoints: "normalPoints";
+                doublePoints: "doublePoints";
+                noPoints: "noPoints";
+            }>;
+            type: z.ZodLiteral<"short-answer">;
+            acceptedAnswers: 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<"titleAndText">;
+            title: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            slideType: z.ZodLiteral<"titleAndTextWithImage">;
+            title: z.ZodString;
+            text: z.ZodString;
+            imageHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            slideType: z.ZodLiteral<"comparison">;
+            title: z.ZodString;
+            left: z.ZodString;
+            right: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            slideType: z.ZodLiteral<"titleImageText">;
+            title: z.ZodString;
+            imageHash: z.ZodOptional<z.ZodString>;
+            text: z.ZodString;
+        }, z.core.$strip>], "slideType">;
+    }, z.core.$strip>], "type">>;
+    images: z.ZodRecord<z.ZodString, z.ZodString>;
+    updatedAt: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type QuizFile = z.infer<typeof QuizFileSchema>;
+//# sourceMappingURL=quizfile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quizfile.d.ts","sourceRoot":"","sources":["../../src/schemas/quizfile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqDxB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWzB,CAAC;AAGH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/schemas/quizfile.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+const QuestionPointsSchema = z.enum(["normalPoints", "doublePoints", "noPoints"]);
+const ThemeSchema = z.object({
+    color: z.string(),
+    background: z.string().optional(),
+});
+const SlideLayoutSchema = z.discriminatedUnion("slideType", [
+    z.object({ slideType: z.literal("title"), title: z.string(), subtitle: z.string().optional() }),
+    z.object({ slideType: z.literal("titleAndText"), title: z.string(), text: z.string() }),
+    z.object({ slideType: z.literal("titleAndTextWithImage"), title: z.string(), text: z.string(), imageHash: z.string().optional() }),
+    z.object({ slideType: z.literal("comparison"), title: z.string(), left: z.string(), right: z.string() }),
+    z.object({ slideType: z.literal("titleImageText"), title: z.string(), imageHash: z.string().optional(), text: z.string() }),
+]);
+const BaseQuestionSchema = z.object({
+    question: z.string().min(1),
+    imageHash: z.string().optional(),
+    displayTime: z.number().min(0),
+    timeLimit: z.number().min(1),
+    points: QuestionPointsSchema,
+});
+const MultipleChoiceSchema = BaseQuestionSchema.extend({
+    type: z.literal("multiple-choice"),
+    options: z.array(z.object({ id: z.string(), text: z.string(), isCorrect: z.boolean() })).min(2),
+});
+const TrueFalseSchema = BaseQuestionSchema.extend({
+    type: z.literal("true-false"),
+    answer: z.boolean(),
+});
+const ShortAnswerSchema = BaseQuestionSchema.extend({
+    type: z.literal("short-answer"),
+    acceptedAnswers: z.array(z.string()).min(1),
+});
+const QuestionSchema = z.discriminatedUnion("type", [
+    MultipleChoiceSchema,
+    TrueFalseSchema,
+    ShortAnswerSchema,
+]);
+// --- Quiz Steps ---
+const QuizStepSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("question"), data: QuestionSchema }),
+    z.object({ type: z.literal("slide"), data: SlideLayoutSchema }),
+]);
+// --- Main QuizFile Schema ---
+export const QuizFileSchema = z.object({
+    id: z.string().uuid(),
+    version: z.literal(2),
+    title: z.string().min(1),
+    description: z.string().optional(),
+    theme: ThemeSchema,
+    language: z.string().length(2), // ISO 639-1 format
+    steps: z.array(QuizStepSchema).min(1),
+    images: z.record(z.string(), z.string()), // Hash -> URL/Base64
+    updatedAt: z.string().datetime(), // Validates ISO strings
+    createdAt: z.string().datetime(),
+});

package/dist/slides/comparison.d.ts

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

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

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

package/dist/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/slides/titleImageTextSlide.d.ts

@@ -0,0 +1,9 @@
+import z from "zod";
+export type TitleImageTextSlideLayout = z.infer<typeof TitleImageTextSlideLayoutSchema>;
+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>;
+//# sourceMappingURL=titleImageTextSlide.d.ts.map

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

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

package/dist/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/slides/titleSlide.d.ts

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

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

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

package/dist/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/types/events.d.ts

@@ -0,0 +1,16 @@
+import { LobbyJoined } from "../events/server/lobby-joined";
+import { PlayerJoined } from "../events/server/player-joined";
+import { PlayerLeft } from "../events/server/player-left";
+import { PlayerUpdate } from "../events/server/player-update";
+import { LobbyStatusUpdate } from "../events/server/lobby-status-update";
+import { UpdateLobbyAnswers } from "../events/server/update-lobby-answers";
+import { PlayerAnswerResult } from "../events/server/player-answer-result";
+import { PlayerKicked } from "../events/server/player-kicked";
+import { LobbyDeleted } from "../events/server/lobby-deleted";
+import { KickPlayer } from "../events/client/host/kick-player";
+import { StartLobby } from "../events/client/host/start-lobby";
+import { NextStep } from "../events/client/host/next-step";
+import { SubmitAnswer } from "../events/client/player/submit-answer";
+export type AllClientEvents = KickPlayer | StartLobby | NextStep | SubmitAnswer;
+export type AllServerEvents = PlayerJoined | PlayerLeft | PlayerUpdate | LobbyStatusUpdate | UpdateLobbyAnswers | PlayerAnswerResult | PlayerKicked | LobbyDeleted | LobbyJoined;
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/types/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAGrE,MAAM,MAAM,eAAe,GACzB,UAAU,GACV,UAAU,GACV,QAAQ,GACR,YAAY,CAAC;AAGf,MAAM,MAAM,eAAe,GACzB,YAAY,GACZ,UAAU,GACV,YAAY,GACZ,iBAAiB,GACjB,kBAAkB,GAClB,kBAAkB,GAClB,YAAY,GACZ,YAAY,GACZ,WAAW,CAAC"}

package/dist/types/events.js

@@ -0,0 +1 @@
+export {};

package/dist/types/lobby.d.ts

@@ -0,0 +1,42 @@
+import { Answer } from "../util/validator";
+import { QuizFile } from "./quizfile";
+import { QuizTheme } from "./quiztheme";
+export type Lobby = {
+    code: string;
+    host: string;
+    quiz: QuizFile;
+    quizInfo: {
+        title: string;
+        stepCount: number;
+        theme: QuizTheme;
+    };
+    players: Player[];
+    status: LobbyStatus;
+    timeoutStartedAt: number | null;
+    duration: number | null;
+    currentStep: number;
+    currentAnswers: Answer[];
+    answers: Answer[];
+    settings: LobbySettings;
+};
+export type LobbySettings = {
+    customNames: boolean;
+    displayOnDevice: boolean;
+};
+export declare enum LobbyStatus {
+    waiting = "waiting",
+    slide = "slide",
+    question = "question",
+    answer = "answer",
+    answers = "answers",
+    score = "score",
+    end = "end"
+}
+export type Player = {
+    id: string;
+    name: string;
+    score: number;
+    streak: number;
+    isConnected: boolean;
+};
+//# sourceMappingURL=lobby.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lobby.d.ts","sourceRoot":"","sources":["../../src/types/lobby.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,EAAE,SAAS,CAAC;KAClB,CAAC;IACF,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;IACpB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,aAAa,CAAC;CACzB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAA;AAED,oBAAY,WAAW;IACrB,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,GAAG,QAAQ;CACZ;AAED,MAAM,MAAM,MAAM,GAAG;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,OAAO,CAAC;CACtB,CAAA"}

package/dist/types/lobby.js

@@ -0,0 +1,10 @@
+export var LobbyStatus;
+(function (LobbyStatus) {
+    LobbyStatus["waiting"] = "waiting";
+    LobbyStatus["slide"] = "slide";
+    LobbyStatus["question"] = "question";
+    LobbyStatus["answer"] = "answer";
+    LobbyStatus["answers"] = "answers";
+    LobbyStatus["score"] = "score";
+    LobbyStatus["end"] = "end";
+})(LobbyStatus || (LobbyStatus = {}));

package/dist/types/question.d.ts

@@ -0,0 +1,106 @@
+import z from "zod";
+import { MultipleChoiceQuestion, SafeMultipleChoiceQuestion } from "./questions/multiple-choice";
+import { SafeTrueFalseQuestion, TrueFalseQuestion } from "./questions/true-false";
+import { SafeShortAnswerQuestion, ShortAnswerQuestion } from "./questions/short-answer";
+export type Question = MultipleChoiceQuestion | TrueFalseQuestion | ShortAnswerQuestion;
+export declare const QuestionSchema: 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">;
+export type SafeQuestion = SafeMultipleChoiceQuestion | SafeTrueFalseQuestion | SafeShortAnswerQuestion;
+export declare const SafeQuestionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    points: z.ZodEnum<{
+        normalPoints: "normalPoints";
+        doublePoints: "doublePoints";
+        noPoints: "noPoints";
+    }>;
+    type: z.ZodLiteral<"multiple-choice">;
+    question: z.ZodString;
+    imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+    displayTime: z.ZodNumber;
+    timeLimit: z.ZodNumber;
+    matchAll: z.ZodBoolean;
+    choices: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    points: z.ZodEnum<{
+        normalPoints: "normalPoints";
+        doublePoints: "doublePoints";
+        noPoints: "noPoints";
+    }>;
+    type: z.ZodLiteral<"true-false">;
+    question: z.ZodString;
+    imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+    displayTime: z.ZodNumber;
+    timeLimit: z.ZodNumber;
+    labels: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    points: z.ZodEnum<{
+        normalPoints: "normalPoints";
+        doublePoints: "doublePoints";
+        noPoints: "noPoints";
+    }>;
+    type: z.ZodLiteral<"short-answer">;
+    question: z.ZodString;
+    imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+    displayTime: z.ZodNumber;
+    timeLimit: z.ZodNumber;
+}, z.core.$strip>], "type">;
+export type QuestionPoints = z.infer<typeof QuestionPointsSchema>;
+export declare const QuestionPointsSchema: z.ZodEnum<{
+    normalPoints: "normalPoints";
+    doublePoints: "doublePoints";
+    noPoints: "noPoints";
+}>;
+export type BaseQuestion = z.infer<typeof BaseQuestionSchema>;
+export declare const BaseQuestionSchema: 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";
+    }>;
+}, z.core.$strip>;
+//# sourceMappingURL=question.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["../../src/types/question.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,EAAE,sBAAsB,EAAgC,0BAA0B,EAAoC,MAAM,6BAA6B,CAAC;AACjK,OAAO,EAAE,qBAAqB,EAA+B,iBAAiB,EAA2B,MAAM,wBAAwB,CAAC;AACxI,OAAO,EAAE,uBAAuB,EAAiC,mBAAmB,EAA6B,MAAM,0BAA0B,CAAC;AAElJ,MAAM,MAAM,QAAQ,GAAG,sBAAsB,GAAG,iBAAiB,GAAG,mBAAmB,CAAC;AAExF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIzB,CAAC;AAEH,MAAM,MAAM,YAAY,GACpB,0BAA0B,GAC1B,qBAAqB,GACrB,uBAAuB,CAAC;AAE5B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAI7B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,oBAAoB;;;;EAAuD,CAAC;AAEzF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,kBAAkB;;;;;;;;;;iBAM7B,CAAC"}

package/dist/types/question.js

@@ -0,0 +1,22 @@
+import z from "zod";
+import { MultipleChoiceQuestionSchema, SafeMultipleChoiceQuestionSchema } from "./questions/multiple-choice";
+import { SafeTrueFalseQuestionSchema, TrueFalseQuestionSchema } from "./questions/true-false";
+import { SafeShortAnswerQuestionSchema, ShortAnswerQuestionSchema } from "./questions/short-answer";
+export const QuestionSchema = z.discriminatedUnion("type", [
+    MultipleChoiceQuestionSchema,
+    TrueFalseQuestionSchema,
+    ShortAnswerQuestionSchema,
+]);
+export const SafeQuestionSchema = z.discriminatedUnion("type", [
+    SafeMultipleChoiceQuestionSchema,
+    SafeTrueFalseQuestionSchema,
+    SafeShortAnswerQuestionSchema,
+]);
+export const QuestionPointsSchema = z.enum(["normalPoints", "doublePoints", "noPoints"]);
+export const BaseQuestionSchema = z.object({
+    question: z.string().min(1),
+    imageHash: z.hash("sha256", { error: "Invalid image hash" }).optional(),
+    displayTime: z.number().min(1).max(60),
+    timeLimit: z.number().min(1).max(180),
+    points: QuestionPointsSchema,
+});

package/dist/types/questions/multiple-choice.d.ts

@@ -0,0 +1,51 @@
+import z from "zod";
+export declare const ChoiceSchema: z.ZodObject<{
+    text: z.ZodString;
+    correct: z.ZodBoolean;
+}, z.core.$strip>;
+export type Choice = z.infer<typeof ChoiceSchema>;
+export declare const SafeChoiceSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strip>;
+export type SafeChoice = z.infer<typeof SafeChoiceSchema>;
+export declare const MultipleChoiceQuestionSchema: 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>;
+export type MultipleChoiceQuestion = z.infer<typeof MultipleChoiceQuestionSchema>;
+export declare const SafeMultipleChoiceQuestionSchema: z.ZodObject<{
+    points: z.ZodEnum<{
+        normalPoints: "normalPoints";
+        doublePoints: "doublePoints";
+        noPoints: "noPoints";
+    }>;
+    type: z.ZodLiteral<"multiple-choice">;
+    question: z.ZodString;
+    imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+    displayTime: z.ZodNumber;
+    timeLimit: z.ZodNumber;
+    matchAll: z.ZodBoolean;
+    choices: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SafeMultipleChoiceQuestion = z.infer<typeof SafeMultipleChoiceQuestionSchema>;
+export declare const MultipleChoiceQuestionAnswerSchema: z.ZodObject<{
+    type: z.ZodLiteral<"multiple-choice">;
+    choices: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+export type MultipleChoiceQuestionAnswer = z.infer<typeof MultipleChoiceQuestionAnswerSchema>;
+//# sourceMappingURL=multiple-choice.d.ts.map

package/dist/types/questions/multiple-choice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiple-choice.d.ts","sourceRoot":"","sources":["../../../src/types/questions/multiple-choice.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB,eAAO,MAAM,YAAY;;;iBAGvB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD,eAAO,MAAM,gBAAgB;;iBAAuC,CAAC;AAErE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;iBAIvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;iBAI3C,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F,eAAO,MAAM,kCAAkC;;;iBAG7C,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC"}

package/dist/types/questions/multiple-choice.js

@@ -0,0 +1,21 @@
+import z from "zod";
+import { BaseQuestionSchema } from "../question";
+export const ChoiceSchema = z.object({
+    text: z.string(),
+    correct: z.boolean(),
+});
+export const SafeChoiceSchema = ChoiceSchema.omit({ correct: true });
+export const MultipleChoiceQuestionSchema = BaseQuestionSchema.extend({
+    type: z.literal("multiple-choice"),
+    choices: z.array(ChoiceSchema).min(2),
+    matchAll: z.boolean(),
+});
+export const SafeMultipleChoiceQuestionSchema = MultipleChoiceQuestionSchema.omit({
+    choices: true
+}).extend({
+    choices: z.array(SafeChoiceSchema).min(2),
+});
+export const MultipleChoiceQuestionAnswerSchema = z.object({
+    type: z.literal("multiple-choice"),
+    choices: z.array(z.number()).min(1),
+});

package/dist/types/questions/short-answer.d.ts

@@ -0,0 +1,34 @@
+import z from "zod";
+export declare const ShortAnswerQuestionSchema: 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>;
+export type ShortAnswerQuestion = z.infer<typeof ShortAnswerQuestionSchema>;
+export declare const SafeShortAnswerQuestionSchema: z.ZodObject<{
+    points: z.ZodEnum<{
+        normalPoints: "normalPoints";
+        doublePoints: "doublePoints";
+        noPoints: "noPoints";
+    }>;
+    type: z.ZodLiteral<"short-answer">;
+    question: z.ZodString;
+    imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+    displayTime: z.ZodNumber;
+    timeLimit: z.ZodNumber;
+}, z.core.$strip>;
+export type SafeShortAnswerQuestion = z.infer<typeof SafeShortAnswerQuestionSchema>;
+export declare const ShortAnswerQuestionAnswerSchema: z.ZodObject<{
+    type: z.ZodLiteral<"short-answer">;
+    answer: z.ZodString;
+}, z.core.$strip>;
+export type ShortAnswerQuestionAnswer = z.infer<typeof ShortAnswerQuestionAnswerSchema>;
+//# sourceMappingURL=short-answer.d.ts.map

package/dist/types/questions/short-answer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"short-answer.d.ts","sourceRoot":"","sources":["../../../src/types/questions/short-answer.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;iBAGpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,6BAA6B;;;;;;;;;;;iBAAoD,CAAC;AAE/F,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,eAAO,MAAM,+BAA+B;;;iBAG1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/dist/types/questions/short-answer.js

@@ -0,0 +1,11 @@
+import z from "zod";
+import { BaseQuestionSchema } from "../question";
+export const ShortAnswerQuestionSchema = BaseQuestionSchema.extend({
+    type: z.literal("short-answer"),
+    answers: z.array(z.string()).min(1),
+});
+export const SafeShortAnswerQuestionSchema = ShortAnswerQuestionSchema.omit({ answers: true });
+export const ShortAnswerQuestionAnswerSchema = z.object({
+    type: z.literal("short-answer"),
+    answer: z.string(),
+});

package/dist/types/questions/true-false.d.ts

@@ -0,0 +1,36 @@
+import z from "zod";
+export declare const TrueFalseQuestionSchema: 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>;
+export type TrueFalseQuestion = z.infer<typeof TrueFalseQuestionSchema>;
+export declare const SafeTrueFalseQuestionSchema: z.ZodObject<{
+    points: z.ZodEnum<{
+        normalPoints: "normalPoints";
+        doublePoints: "doublePoints";
+        noPoints: "noPoints";
+    }>;
+    type: z.ZodLiteral<"true-false">;
+    question: z.ZodString;
+    imageHash: z.ZodOptional<z.ZodCustomStringFormat<"sha256_hex">>;
+    displayTime: z.ZodNumber;
+    timeLimit: z.ZodNumber;
+    labels: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type SafeTrueFalseQuestion = z.infer<typeof SafeTrueFalseQuestionSchema>;
+export declare const TrueFalseQuestionAnswerSchema: z.ZodObject<{
+    type: z.ZodLiteral<"true-false">;
+    answer: z.ZodBoolean;
+}, z.core.$strip>;
+export type TrueFalseQuestionAnswer = z.infer<typeof TrueFalseQuestionAnswerSchema>;
+//# sourceMappingURL=true-false.d.ts.map

package/dist/types/questions/true-false.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"true-false.d.ts","sourceRoot":"","sources":["../../../src/types/questions/true-false.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;iBAIlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;iBAAiD,CAAC;AAE1F,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,6BAA6B;;;iBAGxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

package/dist/types/questions/true-false.js

@@ -0,0 +1,12 @@
+import z from "zod";
+import { BaseQuestionSchema } from "../question";
+export const TrueFalseQuestionSchema = BaseQuestionSchema.extend({
+    type: z.literal("true-false"),
+    answer: z.boolean(),
+    labels: z.array(z.string()).min(2).max(2),
+});
+export const SafeTrueFalseQuestionSchema = TrueFalseQuestionSchema.omit({ answer: true });
+export const TrueFalseQuestionAnswerSchema = z.object({
+    type: z.literal("true-false"),
+    answer: z.boolean(),
+});