@tinyweb_dev/oe-exam-sdk 0.1.27 → 0.1.29

package/dist/shared/lib/hooks/useConfirmDialog.js

@@ -1 +1,89 @@
-"use client";import{useCallback as n,useState as i}from"react";const e={confirmLabel:"Confirm",cancelLabel:"Cancel",isDestructive:!1};export function useConfirmDialog(){const[o,c]=i({isOpen:!1,isLoading:!1,title:"",description:"",...e}),a=n(n=>{c(i=>({...i,...n,isOpen:!0,isLoading:!1,onConfirm:n.onConfirm,onCancel:n.onCancel}))},[]),l=n(()=>{c(n=>({...n,isOpen:!1}))},[]),r=n(n=>{c(i=>({...i,isLoading:n}))},[]),s=n(async()=>{if(o.onConfirm)try{r(!0),await o.onConfirm(),l()}finally{r(!1)}},[o.onConfirm,r,l]),t=n(()=>{o.onCancel&&o.onCancel(),l()},[o.onCancel,l]);return{isOpen:o.isOpen,isLoading:o.isLoading,config:{title:o.title,description:o.description,confirmLabel:o.confirmLabel||e.confirmLabel,cancelLabel:o.cancelLabel||e.cancelLabel,isDestructive:o.isDestructive||e.isDestructive},confirm:a,close:l,handleConfirm:s,handleCancel:t}}
+'use client';
+import { useCallback, useState } from 'react';
+const DEFAULT_CONFIG = {
+    confirmLabel: 'Confirm',
+    cancelLabel: 'Cancel',
+    isDestructive: false,
+};
+/**
+ * Hook for managing confirmation dialogs
+ * Use this when you need user confirmation before performing an action
+ *
+ * @example
+ * const { isOpen, config, confirm } = useConfirmDialog();
+ *
+ * const handleDelete = () => {
+ *   confirm({
+ *     title: 'Delete Item',
+ *     description: 'Are you sure you want to delete this item?',
+ *     isDestructive: true,
+ *     onConfirm: async () => {
+ *       await deleteItem();
+ *     }
+ *   });
+ * };
+ */
+export function useConfirmDialog() {
+    const [state, setState] = useState({
+        isOpen: false,
+        isLoading: false,
+        title: '',
+        description: '',
+        ...DEFAULT_CONFIG,
+    });
+    const confirm = useCallback((config) => {
+        setState((prev) => ({
+            ...prev,
+            ...config,
+            isOpen: true,
+            isLoading: false,
+            onConfirm: config.onConfirm,
+            onCancel: config.onCancel,
+        }));
+    }, []);
+    const close = useCallback(() => {
+        setState((prev) => ({
+            ...prev,
+            isOpen: false,
+        }));
+    }, []);
+    const setLoading = useCallback((isLoading) => {
+        setState((prev) => ({
+            ...prev,
+            isLoading,
+        }));
+    }, []);
+    const handleConfirm = useCallback(async () => {
+        if (state.onConfirm) {
+            try {
+                setLoading(true);
+                await state.onConfirm();
+                close();
+            }
+            finally {
+                setLoading(false);
+            }
+        }
+    }, [state.onConfirm, setLoading, close]);
+    const handleCancel = useCallback(() => {
+        if (state.onCancel) {
+            state.onCancel();
+        }
+        close();
+    }, [state.onCancel, close]);
+    return {
+        isOpen: state.isOpen,
+        isLoading: state.isLoading,
+        config: {
+            title: state.title,
+            description: state.description,
+            confirmLabel: state.confirmLabel || DEFAULT_CONFIG.confirmLabel,
+            cancelLabel: state.cancelLabel || DEFAULT_CONFIG.cancelLabel,
+            isDestructive: state.isDestructive || DEFAULT_CONFIG.isDestructive,
+        },
+        confirm,
+        close,
+        handleConfirm,
+        handleCancel,
+    };
+}

package/dist/shared/lib/hooks/useDebouncedCallback.js

@@ -1 +1,32 @@
-import{useCallback as r,useRef as e,useEffect as t}from"react";export function useDebouncedCallback(u,c){const n=e(u),o=e(null);t(()=>{n.current=u},[u]),t(()=>()=>{o.current&&clearTimeout(o.current)},[]);return r((...r)=>{o.current&&clearTimeout(o.current),o.current=setTimeout(()=>{n.current(...r)},c)},[c])}
+import { useCallback, useRef, useEffect } from 'react';
+/**
+ * Custom hook for debouncing a callback function
+ * @param callback The function to debounce
+ * @param delay The debounce delay in milliseconds
+ * @returns A debounced version of the callback
+ */
+export function useDebouncedCallback(callback, delay) {
+    const callbackRef = useRef(callback);
+    const timeoutRef = useRef(null);
+    // Keep callback ref up to date
+    useEffect(() => {
+        callbackRef.current = callback;
+    }, [callback]);
+    // Cleanup timeout on unmount
+    useEffect(() => {
+        return () => {
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+            }
+        };
+    }, []);
+    const debouncedCallback = useCallback((...args) => {
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+        }
+        timeoutRef.current = setTimeout(() => {
+            callbackRef.current(...args);
+        }, delay);
+    }, [delay]);
+    return debouncedCallback;
+}

package/dist/shared/lib/hooks/useDelayedAutoPlay.js

@@ -1 +1,12 @@
-"use client";import{useEffect as e}from"react";export const DEFAULT_AUTO_PLAY_DELAY_MS=3e3;export function useDelayedAutoPlay({audioRef:t,audioUrl:r,delayMs:o=3e3,enabled:n=!0}){e(()=>{if(!n||!t.current||!r)return;const e=t.current,u=window.setTimeout(()=>{e.play().catch(()=>{})},o);return()=>window.clearTimeout(u)},[t,r,o,n])}
+'use client';
+import { useEffect } from 'react';
+export const DEFAULT_AUTO_PLAY_DELAY_MS = 3000;
+export function useDelayedAutoPlay({ audioRef, audioUrl, delayMs = DEFAULT_AUTO_PLAY_DELAY_MS, enabled = true }) {
+    useEffect(() => {
+        if (!enabled || !audioRef.current || !audioUrl)
+            return;
+        const audio = audioRef.current;
+        const timer = window.setTimeout(() => { void audio.play().catch(() => undefined); }, delayMs);
+        return () => window.clearTimeout(timer);
+    }, [audioRef, audioUrl, delayMs, enabled]);
+}

package/dist/shared/lib/hooks/useFileUpload.js

@@ -1 +1,24 @@
-import{useState as r,useCallback as n}from"react";export function useFileUpload(e={}){const[o,l]=r(!1),[t,c]=r(null),a=n(async r=>{l(!0),c(null);try{const n=URL.createObjectURL(r);return e.onSuccess?.(n,n),{key:n,presignedUrl:n}}catch(r){const n=r instanceof Error?r:new Error("Upload failed");return c(n),e.onError?.(n),null}finally{l(!1)}},[e]);return{uploadFile:a,isUploading:o,error:t}}
+import { useState, useCallback } from 'react';
+export function useFileUpload(options = {}) {
+    const [isUploading, setIsUploading] = useState(false);
+    const [error, setError] = useState(null);
+    const uploadFile = useCallback(async (file) => {
+        setIsUploading(true);
+        setError(null);
+        try {
+            const url = URL.createObjectURL(file);
+            options.onSuccess?.(url, url);
+            return { key: url, presignedUrl: url };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Upload failed');
+            setError(error);
+            options.onError?.(error);
+            return null;
+        }
+        finally {
+            setIsUploading(false);
+        }
+    }, [options]);
+    return { uploadFile, isUploading, error };
+}

package/dist/shared/lib/hooks/useImageUrl.js

@@ -1 +1,5 @@
-"use client";import{usePresignedFileUrl as e}from"./usePresignedFileUrl";export function useImageUrl(r){return e(r).previewUrl||r||""}
+'use client';
+import { usePresignedFileUrl } from './usePresignedFileUrl';
+export function useImageUrl(src) {
+    return usePresignedFileUrl(src).previewUrl || src || '';
+}

package/dist/shared/lib/hooks/usePresignedFileUrl.js

@@ -1 +1,108 @@
-import{useEffect as t,useMemo as r,useState as e}from"react";const n=(process.env.NEXT_PUBLIC_API_URL??"").replace(/\/+$/,"");const s=new Map,i=new Map;export function usePresignedFileUrl(o){const a="string"==typeof o?o:"",l=r(()=>{return a&&((t=a).startsWith("http://")||t.startsWith("https://")||t.startsWith("blob:")||t.startsWith("data:"))?a:"";var t},[a]),[c,u]=e(()=>l||s.get(a)||""),[f,d]=e(!1),[p,g]=e(null);return t(()=>{if(!a||l)return u(l),d(!1),void g(null);const t=s.get(a);if(t)return u(t),d(!1),void g(null);let r=!0;return d(!0),g(null),async function(t){const r=s.get(t);if(r)return r;const e=i.get(t);if(e)return e;const o=(async()=>{if(!n)return t;const r=await fetch(`${n}/api/v1/exam-storage/${encodeURIComponent(t)}`,{credentials:"include"});if(!r.ok)throw new Error(`Failed to resolve file URL (${r.status})`);const e=await r.json(),i="data"in e?e.data?.url:e.url;if(!i)throw new Error("Presigned URL missing in response");return s.set(t,i),i})().finally(()=>{i.delete(t)});return i.set(t,o),o}(a).then(t=>{r&&(u(t),d(!1))}).catch(t=>{r&&(g(t instanceof Error?t:new Error(String(t))),u(""),d(!1))}),()=>{r=!1}},[a,l]),{previewUrl:c,isLoading:f,error:p}}
+import { useEffect, useMemo, useState } from 'react';
+/**
+ * Base URL of the host API that resolves exam-owned storage keys to presigned
+ * URLs. The host app (oe-class) exposes `GET /api/v1/exam-storage/:key`, which
+ * proxies to oe-exam-api so files are signed against the bucket that actually
+ * owns them. Reads NEXT_PUBLIC_API_URL — inlined at build time in the host.
+ */
+const HOST_API_BASE_URL = (process.env.NEXT_PUBLIC_API_URL ?? '').replace(/\/+$/, '');
+const EXAM_STORAGE_PATH = '/api/v1/exam-storage';
+/** A resolved key is displayable as-is when it's already a URL or inline data. */
+function isDisplayableUrl(value) {
+    return (value.startsWith('http://') ||
+        value.startsWith('https://') ||
+        value.startsWith('blob:') ||
+        value.startsWith('data:'));
+}
+// Module-level cache so many hook instances resolving the same key (e.g. a
+// speaking review page with dozens of clips) share a single network request
+// and a stable resolved URL. Presigned URLs are short-lived but the SDK only
+// needs them for the lifetime of a page view.
+const urlCache = new Map();
+const inFlight = new Map();
+async function resolvePresignedUrl(key) {
+    const cached = urlCache.get(key);
+    if (cached)
+        return cached;
+    const pending = inFlight.get(key);
+    if (pending)
+        return pending;
+    const promise = (async () => {
+        if (!HOST_API_BASE_URL) {
+            // No host API configured — best effort: return the key unchanged so the
+            // caller at least doesn't crash. It won't load, but nothing throws.
+            return key;
+        }
+        const response = await fetch(`${HOST_API_BASE_URL}${EXAM_STORAGE_PATH}/${encodeURIComponent(key)}`, { credentials: 'include' });
+        if (!response.ok) {
+            throw new Error(`Failed to resolve file URL (${response.status})`);
+        }
+        const body = (await response.json());
+        const resolved = 'data' in body ? body.data?.url : body.url;
+        if (!resolved) {
+            throw new Error('Presigned URL missing in response');
+        }
+        urlCache.set(key, resolved);
+        return resolved;
+    })().finally(() => {
+        inFlight.delete(key);
+    });
+    inFlight.set(key, promise);
+    return promise;
+}
+/**
+ * Resolve a storage reference to a displayable URL.
+ *
+ * - Empty/undefined → empty string.
+ * - Already a URL (http/https/blob/data) → returned unchanged.
+ * - An S3 storage key (e.g. `exams/:id/audio/x.wav`) → resolved to a presigned
+ *   URL via the host API (`/api/v1/exam-storage/:key`).
+ */
+export function usePresignedFileUrl(fileKey) {
+    const safeKey = typeof fileKey === 'string' ? fileKey : '';
+    const passthrough = useMemo(() => (safeKey && isDisplayableUrl(safeKey) ? safeKey : ''), [safeKey]);
+    const [resolvedUrl, setResolvedUrl] = useState(() => passthrough || urlCache.get(safeKey) || '');
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        // Passthrough URLs and empty keys need no resolution.
+        if (!safeKey || passthrough) {
+            setResolvedUrl(passthrough);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+        const cached = urlCache.get(safeKey);
+        if (cached) {
+            setResolvedUrl(cached);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+        let active = true;
+        setIsLoading(true);
+        setError(null);
+        resolvePresignedUrl(safeKey)
+            .then((url) => {
+            if (active) {
+                setResolvedUrl(url);
+                setIsLoading(false);
+            }
+        })
+            .catch((err) => {
+            if (active) {
+                setError(err instanceof Error ? err : new Error(String(err)));
+                setResolvedUrl('');
+                setIsLoading(false);
+            }
+        });
+        return () => {
+            active = false;
+        };
+    }, [safeKey, passthrough]);
+    return {
+        previewUrl: resolvedUrl,
+        isLoading,
+        error,
+    };
+}

package/dist/shared/lib/hooks/useReactHookForm.js

@@ -1 +1,31 @@
-import{useForm as r}from"react-hook-form";import{zodResolver as o}from"@hookform/resolvers/zod";export const useReactHookForm=e=>{const{zodSchema:t,...a}=e,s=r({resolver:t?o(t):void 0,mode:"onSubmit",reValidateMode:"onChange",...a});return{...s,setFieldValue:(r,o)=>{s.setValue(r,o,{shouldValidate:!0})},clearFieldError:r=>{s.clearErrors(r)},hasError:r=>!!s.formState.errors[r],getFieldError:r=>s.formState.errors[r]?.message}};
+import { useForm as useRHF } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+/**
+ * Wrapper hook cho React Hook Form với Zod integration
+ * Cung cấp interface đơn giản hơn và tích hợp sẵn Zod resolver
+ */
+export const useReactHookForm = (options) => {
+    const { zodSchema, ...formOptions } = options;
+    const form = useRHF({
+        resolver: zodSchema ? zodResolver(zodSchema) : undefined,
+        mode: 'onSubmit',
+        reValidateMode: 'onChange', // After errors appear, re-validate on change to clear them
+        ...formOptions,
+    });
+    return {
+        ...form,
+        // Helper methods for easier usage
+        setFieldValue: (field, value) => {
+            form.setValue(field, value, { shouldValidate: true });
+        },
+        clearFieldError: (field) => {
+            form.clearErrors(field);
+        },
+        hasError: (field) => {
+            return !!form.formState.errors[field];
+        },
+        getFieldError: (field) => {
+            return form.formState.errors[field]?.message;
+        },
+    };
+};

package/dist/shared/lib/hooks/useToast.js

@@ -1 +1,62 @@
-"use client";import{toast as i}from"sonner";import{useCallback as n}from"react";export function useToast(){return{success:n(n=>{i.success(n.message,{description:n.description,duration:n.duration,action:n.action})},[]),error:n(n=>{i.error(n.message,{description:n.description,duration:n.duration,action:n.action})},[]),info:n(n=>{i.info(n.message,{description:n.description,duration:n.duration,action:n.action})},[]),warning:n(n=>{i.warning(n.message,{description:n.description,duration:n.duration,action:n.action})},[]),loading:n(n=>{i.loading(n.message,{description:n.description})},[])}}
+'use client';
+import { toast } from 'sonner';
+import { useCallback } from 'react';
+/**
+ * Hook for showing toast notifications using Sonner
+ * Use this hook instead of alert() for non-blocking notifications
+ *
+ * @example
+ * const { success, error, info, warning } = useToast();
+ *
+ * success({
+ *   message: 'Success!',
+ *   description: 'Your action was completed'
+ * });
+ *
+ * error({
+ *   message: 'Error!',
+ *   description: 'Something went wrong'
+ * });
+ */
+export function useToast() {
+    const success = useCallback((config) => {
+        toast.success(config.message, {
+            description: config.description,
+            duration: config.duration,
+            action: config.action,
+        });
+    }, []);
+    const error = useCallback((config) => {
+        toast.error(config.message, {
+            description: config.description,
+            duration: config.duration,
+            action: config.action,
+        });
+    }, []);
+    const info = useCallback((config) => {
+        toast.info(config.message, {
+            description: config.description,
+            duration: config.duration,
+            action: config.action,
+        });
+    }, []);
+    const warning = useCallback((config) => {
+        toast.warning(config.message, {
+            description: config.description,
+            duration: config.duration,
+            action: config.action,
+        });
+    }, []);
+    const loading = useCallback((config) => {
+        toast.loading(config.message, {
+            description: config.description,
+        });
+    }, []);
+    return {
+        success,
+        error,
+        info,
+        warning,
+        loading,
+    };
+}

package/dist/shared/lib/html-content.js

@@ -1 +1,22 @@
-"use client";import{jsx as t}from"react/jsx-runtime";import{cn as l}from"../lib/utils";export function isHtmlContent(t){return/<[a-z][\s\S]*>/i.test(t)}export function HtmlOrText({value:e,className:s,as:i="p"}){if(!e)return null;if(isHtmlContent(e))return t("div",{className:l("[&_p]:mb-2 [&_p:last-child]:mb-0 [&_ul]:my-2 [&_ul]:list-disc [&_ul]:pl-5 [&_ol]:my-2 [&_ol]:list-decimal [&_ol]:pl-5 [&_strong]:font-semibold",s),dangerouslySetInnerHTML:{__html:e}});return t(i,{className:s,children:e})}
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from '../lib/utils';
+/** Detects whether a CMS string carries HTML markup vs plain text. */
+export function isHtmlContent(value) {
+    return /<[a-z][\s\S]*>/i.test(value);
+}
+/**
+ * Renders CMS-authored content as HTML when it contains tags, otherwise as
+ * plain text. Content comes from the exam CMS (not end-user input).
+ */
+export function HtmlOrText({ value, className, as = 'p' }) {
+    if (!value)
+        return null;
+    if (isHtmlContent(value)) {
+        return (_jsx("div", { className: cn('[&_p]:mb-2 [&_p:last-child]:mb-0 [&_ul]:my-2 [&_ul]:list-disc [&_ul]:pl-5 [&_ol]:my-2 [&_ol]:list-decimal [&_ol]:pl-5 [&_strong]:font-semibold', className), 
+            // Exam CMS content — not user-generated input.
+            dangerouslySetInnerHTML: { __html: value } }));
+    }
+    const Tag = as;
+    return _jsx(Tag, { className: className, children: value });
+}

package/dist/shared/lib/i18n/index.js

@@ -1 +1,54 @@
-import{useCallback as e}from"react";import{useLocaleStore as r}from"../../lib/stores/localeStore";import o from"./messages/vi";import n from"./messages/en";export const SUPPORTED_LOCALES=["vi","en"];const c={vi:o,en:n};export function getLocale(){return r.getState().locale}export function t(e,r){const o=getLocale();let n=c[o]?.[e]??c.vi[e]??e;return r&&Object.entries(r).forEach(([e,r])=>{n=n.replace(new RegExp(`\\{${e}\\}`,"g"),String(r))}),n}export function useT(){const o=r(e=>e.locale);return e((e,r)=>{let n=c[o]?.[e]??c.vi[e]??e;return r&&Object.entries(r).forEach(([e,r])=>{n=n.replace(new RegExp(`\\{${e}\\}`,"g"),String(r))}),n},[o])}
+import { useCallback } from 'react';
+import { useLocaleStore } from '../../lib/stores/localeStore';
+import vi from './messages/vi';
+import en from './messages/en';
+export const SUPPORTED_LOCALES = ['vi', 'en'];
+const messages = { vi, en };
+/** Get the current locale from Zustand store (works outside React components) */
+export function getLocale() {
+    return useLocaleStore.getState().locale;
+}
+/**
+ * Translate a message key with optional parameter interpolation.
+ *
+ * Lookup order: messages[currentLocale] → messages['vi'] → raw key.
+ *
+ * **Non-reactive** — reads locale via `getState()` (snapshot).
+ * Use in toast callbacks, event handlers, or outside React components.
+ * For reactive usage inside components, use `useT()` instead.
+ *
+ * @example
+ * t('common.http.400')
+ * t('admin.exam.copy.success', { name: 'Exam 01', count: '10' })
+ */
+export function t(key, params) {
+    const locale = getLocale();
+    let message = messages[locale]?.[key] ?? messages.vi[key] ?? key;
+    if (params) {
+        Object.entries(params).forEach(([k, v]) => {
+            message = message.replace(new RegExp(`\\{${k}\\}`, 'g'), String(v));
+        });
+    }
+    return message;
+}
+/**
+ * Reactive translation hook — subscribes to locale changes via Zustand.
+ *
+ * Components using `useT()` will re-render when the user switches language.
+ *
+ * @example
+ * const t = useT();
+ * return <h1>{t('admin.reports.title')}</h1>;
+ */
+export function useT() {
+    const locale = useLocaleStore((s) => s.locale);
+    return useCallback((key, params) => {
+        let message = messages[locale]?.[key] ?? messages.vi[key] ?? key;
+        if (params) {
+            Object.entries(params).forEach(([k, v]) => {
+                message = message.replace(new RegExp(`\\{${k}\\}`, 'g'), String(v));
+            });
+        }
+        return message;
+    }, [locale]);
+}

package/dist/shared/lib/i18n/messages/en/admin.d.ts

@@ -118,6 +118,12 @@ declare const admin: {
     readonly 'admin.questionBank.dialog.edit.save': "Save changes";
     readonly 'admin.questionBank.dialog.edit.codeError': "Please enter question code";
     readonly 'admin.questionBank.dialog.edit.titleError': "Please enter title";
+    readonly 'admin.questionBank.dialog.edit.loading': "Loading...";
+    readonly 'admin.questionBank.dialog.edit.unsupportedNote': "Note:";
+    readonly 'admin.questionBank.dialog.edit.unsupportedType': "Question type \"{type}\" is not editable in this UI. Please use the exam creator to edit this question.";
+    readonly 'admin.questionBank.dialog.edit.contentLabel': "Question content";
+    readonly 'admin.questionBank.dialog.edit.answerLabel': "Correct answer";
+    readonly 'admin.questionBank.dialog.edit.explanationLabel': "Explanation";
     readonly 'admin.questionBank.dialog.delete.title': "Confirm Delete Question";
     readonly 'admin.questionBank.dialog.delete.message': "Are you sure you want to delete question";
     readonly 'admin.questionBank.dialog.delete.warning': "This action cannot be undone.";
@@ -1387,9 +1393,6 @@ declare const admin: {
     readonly 'admin.exams.shuffle.info3': "Questions within the same Part are randomly shuffled";
     readonly 'admin.exams.shuffle.info4': "Variants are linked to the parent exam for management";
     readonly 'admin.exams.shuffle.countLabel': "Number of variants to create";
-    readonly 'admin.exams.shuffle.strategyLabel': "Existing exam handling option";
-    readonly 'admin.exams.shuffle.keepOld': "Keep existing exams and add new ones";
-    readonly 'admin.exams.shuffle.replaceAll': "Create a completely new set";
     readonly 'admin.exams.shuffle.existingVariants': "Existing exams ({count})";
     readonly 'admin.exams.shuffle.deleteAll': "Delete all ({count})";
     readonly 'admin.exams.shuffle.loading': "Loading...";
@@ -1480,21 +1483,25 @@ declare const admin: {
     readonly 'admin.exams.preview.totalPoints': "Total Points:";
     readonly 'admin.exams.preview.progress': "Progress";
     readonly 'admin.exams.preview.loading': "Loading...";
-    readonly 'admin.exams.preview.questionNavigation': "Question Navigation";
+    readonly 'admin.exams.preview.questionNavigation': "Part Navigation";
     readonly 'admin.exams.preview.all': "All";
     readonly 'admin.exams.preview.allQuestions': "All {count} questions";
     readonly 'admin.exams.preview.partQuestions': "Part {part}: {count} questions";
     readonly 'admin.exams.preview.collapse': "Collapse";
     readonly 'admin.exams.preview.detail': "Details";
     readonly 'admin.exams.preview.questionIndex': "Question {index} / {total}";
+    readonly 'admin.exams.preview.partIndex': "Part {index} / {total}";
     readonly 'admin.exams.preview.noQuestions': "No questions yet";
     readonly 'admin.exams.preview.loadingQuestions': "Loading questions...";
     readonly 'admin.exams.preview.retry': "Retry";
     readonly 'admin.exams.preview.examNoQuestions': "This exam has no questions yet.";
     readonly 'admin.exams.preview.prevQuestion': "Previous Question";
+    readonly 'admin.exams.preview.prevPart': "Previous Part";
     readonly 'admin.exams.preview.prev': "Prev";
     readonly 'admin.exams.preview.nextQuestion': "Next Question";
+    readonly 'admin.exams.preview.nextPart': "Next Part";
     readonly 'admin.exams.preview.next': "Next";
+    readonly 'admin.exams.preview.questionLabel': "Question {number}";
     readonly 'admin.exams.preview.footerNote': "This is a preview mode to check the layout and content of the exam.";
     readonly 'admin.exams.preview.close': "Close";
     readonly 'admin.exams.preview.loadError': "Unable to load questions. Please try again.";