@tinyweb_dev/oe-exam-sdk 0.1.28 → 0.1.29

package/dist/components/exams/take/hooks/useAnswerAutosave.js

@@ -1 +1,71 @@
-"use client";import{useCallback as e,useEffect as r,useRef as n}from"react";export function useAnswerAutosave({api:t,attemptId:i,enabled:s,debounceMs:u=800,onSaveError:c}){const a=n(new Map),o=n(!1),d=n(null),w=n(c);w.current=c;const v=e(async e=>{if(!i||!t.saveAnswers||0===a.current.size)return;const r=Array.from(a.current.entries()).map(([e,r])=>({questionId:e,answer:r}));a.current.clear(),o.current=!1;try{await t.saveAnswers({attemptId:i,answers:r,keepalive:e})}catch(e){r.forEach(({questionId:e,answer:r})=>a.current.set(e,r)),o.current=!0,w.current?.(e)}},[t,i]),m=e(()=>v(!1),[v]),l=e((e,r)=>{s&&(a.current.set(e,r),o.current=!0,d.current&&clearTimeout(d.current),d.current=setTimeout(()=>{v(!1)},u))},[u,v,s]);return r(()=>{if(!s)return;const e=()=>{v(!0)},r=()=>{"hidden"===document.visibilityState&&e()},n=()=>{o.current&&v(!1)};return document.addEventListener("visibilitychange",r),window.addEventListener("pagehide",e),window.addEventListener("online",n),()=>{document.removeEventListener("visibilitychange",r),window.removeEventListener("pagehide",e),window.removeEventListener("online",n),d.current&&clearTimeout(d.current)}},[v,s]),{queueAnswer:l,flushNow:m,hasPendingRef:o}}
+'use client';
+import { useCallback, useEffect, useRef } from 'react';
+/** Default debounce window for batching answer saves. */
+const DEFAULT_DEBOUNCE_MS = 800;
+/**
+ * Buffers answer changes and persists them in debounced batches. Ports the host
+ * app's resilience: a `keepalive` flush on tab hide / page unload and a retry on
+ * the `online` event so answers survive refreshes and flaky networks.
+ */
+export function useAnswerAutosave({ api, attemptId, enabled, debounceMs = DEFAULT_DEBOUNCE_MS, onSaveError, }) {
+    const pendingRef = useRef(new Map());
+    const hasPendingRef = useRef(false);
+    const timerRef = useRef(null);
+    const onSaveErrorRef = useRef(onSaveError);
+    onSaveErrorRef.current = onSaveError;
+    const drain = useCallback(async (keepalive) => {
+        if (!attemptId || !api.saveAnswers || pendingRef.current.size === 0)
+            return;
+        const answers = Array.from(pendingRef.current.entries()).map(([questionId, answer]) => ({
+            questionId,
+            answer,
+        }));
+        pendingRef.current.clear();
+        hasPendingRef.current = false;
+        try {
+            await api.saveAnswers({ attemptId, answers, keepalive });
+        }
+        catch (error) {
+            // Re-buffer so the next flush retries the failed answers.
+            answers.forEach(({ questionId, answer }) => pendingRef.current.set(questionId, answer));
+            hasPendingRef.current = true;
+            onSaveErrorRef.current?.(error);
+        }
+    }, [api, attemptId]);
+    const flushNow = useCallback(() => drain(false), [drain]);
+    const queueAnswer = useCallback((questionId, answer) => {
+        if (!enabled)
+            return;
+        pendingRef.current.set(questionId, answer);
+        hasPendingRef.current = true;
+        if (timerRef.current)
+            clearTimeout(timerRef.current);
+        timerRef.current = setTimeout(() => void drain(false), debounceMs);
+    }, [debounceMs, drain, enabled]);
+    useEffect(() => {
+        if (!enabled)
+            return undefined;
+        const flushKeepalive = () => {
+            void drain(true);
+        };
+        const handleVisibility = () => {
+            if (document.visibilityState === 'hidden')
+                flushKeepalive();
+        };
+        const handleOnline = () => {
+            if (hasPendingRef.current)
+                void drain(false);
+        };
+        document.addEventListener('visibilitychange', handleVisibility);
+        window.addEventListener('pagehide', flushKeepalive);
+        window.addEventListener('online', handleOnline);
+        return () => {
+            document.removeEventListener('visibilitychange', handleVisibility);
+            window.removeEventListener('pagehide', flushKeepalive);
+            window.removeEventListener('online', handleOnline);
+            if (timerRef.current)
+                clearTimeout(timerRef.current);
+        };
+    }, [drain, enabled]);
+    return { queueAnswer, flushNow, hasPendingRef };
+}

package/dist/components/exams/take/hooks/useAttemptSubmit.js

@@ -1 +1,38 @@
-"use client";import{useCallback as t,useState as e}from"react";export function useAttemptSubmit({api:n,flushAnswers:a,onSubmitted:i,onError:s}){const[r,u]=e(!1);return{submit:t(async t=>{if(!r){u(!0);try{a&&await a();const s="object"==typeof(e=await n.submitAttempt(t))&&null!==e&&"data"in e?e.data:e??{};i?.({attemptId:t,pendingAnswerIds:s.pendingAnswerIds??[],manualReviewAnswerIds:s.manualReviewAnswerIds??[],autoGradedCount:s.autoGradedCount??0})}catch(t){s?.(t),u(!1)}var e}},[n,a,r,s,i]),isSubmitting:r}}
+'use client';
+import { useCallback, useState } from 'react';
+/** Envelope guard for adapters returning `{ data }`. */
+function unwrapResult(value) {
+    if (typeof value === 'object' && value !== null && 'data' in value) {
+        return value.data;
+    }
+    return (value ?? {});
+}
+/**
+ * Submits an attempt with the host app's guarantees: flush any buffered answers
+ * first, prevent concurrent submits, and surface the pending/auto-graded answer
+ * ids so the caller can route to the review screen with the right context.
+ */
+export function useAttemptSubmit({ api, flushAnswers, onSubmitted, onError, }) {
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const submit = useCallback(async (attemptId) => {
+        if (isSubmitting)
+            return;
+        setIsSubmitting(true);
+        try {
+            if (flushAnswers)
+                await flushAnswers();
+            const result = unwrapResult(await api.submitAttempt(attemptId));
+            onSubmitted?.({
+                attemptId,
+                pendingAnswerIds: result.pendingAnswerIds ?? [],
+                manualReviewAnswerIds: result.manualReviewAnswerIds ?? [],
+                autoGradedCount: result.autoGradedCount ?? 0,
+            });
+        }
+        catch (error) {
+            onError?.(error);
+            setIsSubmitting(false);
+        }
+    }, [api, flushAnswers, isSubmitting, onError, onSubmitted]);
+    return { submit, isSubmitting };
+}

package/dist/components/exams/take/hooks/useAutoSave.js

@@ -1 +1,83 @@
-import{useState as t,useEffect as r,useRef as e,useCallback as a}from"react";import{useExamTakingStore as n}from"../../../../shared/lib/stores/examTakingStore";import{transformAnswersForSubmission as s}from"../utils/answer-transformers";export function useAutoSave(i){const o=n(),[l,u]=t(!1),[c,S]=t(null),v=e(null),m=i.intervalMs??3e4,p=a(async()=>{if(l||o.isSubmitting||!o.isDirty)return;if(0!==Object.keys(o.answers).length){u(!0),i.onSaveStart?.();try{const t=s(o.answers,i.parts);if(0===t.length)return void o.markSaved();await(i.api.saveAnswers?.({attemptId:i.attemptId,answers:t})),o.markSaved(),S(null),i.onSaveSuccess?.()}catch(t){const r=t;S(r),i.onSaveError?.(r)}finally{u(!1)}}},[i.api,i.attemptId,i.onSaveStart,i.onSaveSuccess,i.onSaveError,l,o.isSubmitting,o.isDirty,o.answers]);return r(()=>(v.current&&clearInterval(v.current),v.current=setInterval(async()=>{!o.isDirty||o.isSubmitting||l||await p()},m),()=>{v.current&&(clearInterval(v.current),v.current=null)}),[m,o.isDirty,o.isSubmitting,l,p]),{isSaving:l,lastSavedAt:o.lastSavedAt,lastError:c,saveNow:p}}
+import { useState, useEffect, useRef, useCallback } from 'react';
+import { useExamTakingStore } from '../../../../shared/lib/stores/examTakingStore';
+import { transformAnswersForSubmission } from '../utils/answer-transformers';
+export function useAutoSave(options) {
+    const store = useExamTakingStore();
+    const [isSaving, setIsSaving] = useState(false);
+    const [lastError, setLastError] = useState(null);
+    const intervalRef = useRef(null);
+    const autoSaveInterval = options.intervalMs ?? 30000; // Default: 30 seconds
+    // Manual save function
+    const saveNow = useCallback(async () => {
+        // Don't save if:
+        // - Already saving
+        // - Store is submitting
+        // - No dirty changes
+        // - No answers to save
+        if (isSaving || store.isSubmitting || !store.isDirty) {
+            return;
+        }
+        const answersCount = Object.keys(store.answers).length;
+        if (answersCount === 0) {
+            return;
+        }
+        setIsSaving(true);
+        options.onSaveStart?.();
+        try {
+            // Transform answers to API format (converts synthetic IDs to proper format)
+            const answersArray = transformAnswersForSubmission(store.answers, options.parts);
+            if (answersArray.length === 0) {
+                store.markSaved();
+                return;
+            }
+            await options.api.saveAnswers?.({ attemptId: options.attemptId, answers: answersArray });
+            store.markSaved();
+            setLastError(null);
+            options.onSaveSuccess?.();
+        }
+        catch (error) {
+            const err = error;
+            setLastError(err);
+            options.onSaveError?.(err);
+        }
+        finally {
+            setIsSaving(false);
+        }
+    }, [
+        options.api,
+        options.attemptId,
+        options.onSaveStart,
+        options.onSaveSuccess,
+        options.onSaveError,
+        isSaving,
+        store.isSubmitting,
+        store.isDirty,
+        store.answers,
+    ]);
+    // Auto-save effect
+    useEffect(() => {
+        // Clear any existing interval
+        if (intervalRef.current) {
+            clearInterval(intervalRef.current);
+        }
+        // Start auto-save interval
+        intervalRef.current = setInterval(async () => {
+            if (store.isDirty && !store.isSubmitting && !isSaving) {
+                await saveNow();
+            }
+        }, autoSaveInterval);
+        // Cleanup on unmount
+        return () => {
+            if (intervalRef.current) {
+                clearInterval(intervalRef.current);
+                intervalRef.current = null;
+            }
+        };
+    }, [autoSaveInterval, store.isDirty, store.isSubmitting, isSaving, saveNow]);
+    return {
+        isSaving,
+        lastSavedAt: store.lastSavedAt,
+        lastError,
+        saveNow,
+    };
+}

package/dist/components/exams/take/hooks/useExamCountdown.js

@@ -1 +1,35 @@
-"use client";import{useEffect as e,useRef as t,useState as r}from"react";export function useExamCountdown({durationMinutes:n,startedAt:o,enabled:c,onExpire:u}){const[a,i]=r(0),s=t(!1),d=t(u);return d.current=u,e(()=>{if(!c||!o)return;const e=new Date(o).getTime()+6e4*n;s.current=!1;const t=()=>{const t=Math.max(0,Math.floor((e-Date.now())/1e3));i(t),t<=0&&!s.current&&(s.current=!0,d.current())};t();const r=setInterval(t,1e3);return()=>clearInterval(r)},[n,c,o]),{remainingSeconds:a,isExpired:s.current}}
+'use client';
+import { useEffect, useRef, useState } from 'react';
+/** One second expressed in milliseconds. */
+const TICK_INTERVAL_MS = 1000;
+/** Minutes-to-milliseconds factor. */
+const MINUTE_IN_MS = 60000;
+/**
+ * Drives the exam timer. Computes remaining seconds from `startedAt + duration`
+ * so the value stays correct across tab refreshes, and invokes `onExpire` once
+ * when time runs out (mirrors the host app's auto-submit trigger).
+ */
+export function useExamCountdown({ durationMinutes, startedAt, enabled, onExpire, }) {
+    const [remainingSeconds, setRemainingSeconds] = useState(0);
+    const hasExpiredRef = useRef(false);
+    const onExpireRef = useRef(onExpire);
+    onExpireRef.current = onExpire;
+    useEffect(() => {
+        if (!enabled || !startedAt)
+            return undefined;
+        const deadline = new Date(startedAt).getTime() + durationMinutes * MINUTE_IN_MS;
+        hasExpiredRef.current = false;
+        const tick = () => {
+            const seconds = Math.max(0, Math.floor((deadline - Date.now()) / 1000));
+            setRemainingSeconds(seconds);
+            if (seconds <= 0 && !hasExpiredRef.current) {
+                hasExpiredRef.current = true;
+                onExpireRef.current();
+            }
+        };
+        tick();
+        const timer = setInterval(tick, TICK_INTERVAL_MS);
+        return () => clearInterval(timer);
+    }, [durationMinutes, enabled, startedAt]);
+    return { remainingSeconds, isExpired: hasExpiredRef.current };
+}

package/dist/components/exams/take/hooks/useExamTimer.js

@@ -1 +1,97 @@
-import{useEffect as n,useRef as e}from"react";import{useExamTakingStore as r}from"../../../../shared/lib/stores/examTakingStore";export function useExamTimer(t){const i=r(),c=e(null),o=e(!1),s=(()=>{const n=t.warningThresholds??[];if(0===n.length&&void 0!==t.warningThresholdSeconds){const n=[];return t.onWarningThreshold&&n.push({seconds:t.warningThresholdSeconds,level:"critical",callback:t.onWarningThreshold}),n}return n})(),l=e(new Set),a=e(t.onTimeExpired);a.current=t.onTimeExpired,n(()=>{if(!i.isInitialized)return;c.current&&clearInterval(c.current),o.current=!1,l.current=new Set;const n=()=>{const n=i.syncRemainingSeconds();for(const e of s)n<=e.seconds&&!l.current.has(e.seconds)&&(l.current.add(e.seconds),e.callback?.());n<=0&&(c.current&&(clearInterval(c.current),c.current=null),o.current||(o.current=!0,a.current()))};c.current=setInterval(n,1e3);const e=()=>{"visible"===document.visibilityState&&n()};return document.addEventListener("visibilitychange",e),window.addEventListener("focus",e),()=>{c.current&&(clearInterval(c.current),c.current=null),document.removeEventListener("visibilitychange",e),window.removeEventListener("focus",e)}},[i.isInitialized]);const u=function(n,e){let r="none";for(const t of e)if(n<=t.seconds&&"none"!==t.level){if("critical"===t.level)return"critical";"warning"===t.level&&(r="warning")}return r}(i.remainingSeconds,s);return{remainingSeconds:i.remainingSeconds,warningLevel:u}}
+import { useEffect, useRef } from 'react';
+import { useExamTakingStore } from '../../../../shared/lib/stores/examTakingStore';
+function getWarningLevel(remainingSeconds, thresholds) {
+    let highest = 'none';
+    for (const t of thresholds) {
+        if (remainingSeconds <= t.seconds && t.level !== 'none') {
+            if (t.level === 'critical')
+                return 'critical';
+            if (t.level === 'warning')
+                highest = 'warning';
+        }
+    }
+    return highest;
+}
+export function useExamTimer(options) {
+    const store = useExamTakingStore();
+    const intervalRef = useRef(null);
+    const timeExpiredCalledRef = useRef(false);
+    // Build effective thresholds — merge deprecated props into array format
+    const effectiveThresholds = (() => {
+        const fromProp = options.warningThresholds ?? [];
+        // Backward-compat: inject deprecated props if no thresholds provided
+        if (fromProp.length === 0 && options.warningThresholdSeconds !== undefined) {
+            const legacy = [];
+            if (options.onWarningThreshold) {
+                legacy.push({
+                    seconds: options.warningThresholdSeconds,
+                    level: 'critical',
+                    callback: options.onWarningThreshold,
+                });
+            }
+            return legacy;
+        }
+        return fromProp;
+    })();
+    // Track which thresholds have already fired (prevents duplicate callbacks)
+    const firedThresholdsRef = useRef(new Set());
+    // Stable callback refs
+    const onTimeExpiredRef = useRef(options.onTimeExpired);
+    onTimeExpiredRef.current = options.onTimeExpired;
+    useEffect(() => {
+        if (!store.isInitialized)
+            return;
+        // Clear existing interval
+        if (intervalRef.current)
+            clearInterval(intervalRef.current);
+        // Reset flags
+        timeExpiredCalledRef.current = false;
+        firedThresholdsRef.current = new Set();
+        // Recompute remaining from wall-clock, fire threshold callbacks, and handle
+        // expiry. Runs every second AND immediately when the tab regains focus, so a
+        // backgrounded/throttled tab never drifts and expiry fires right on return.
+        const tick = () => {
+            const remaining = store.syncRemainingSeconds();
+            // Check warning thresholds
+            for (const t of effectiveThresholds) {
+                if (remaining <= t.seconds && !firedThresholdsRef.current.has(t.seconds)) {
+                    firedThresholdsRef.current.add(t.seconds);
+                    t.callback?.();
+                }
+            }
+            // Time expired
+            if (remaining <= 0) {
+                if (intervalRef.current) {
+                    clearInterval(intervalRef.current);
+                    intervalRef.current = null;
+                }
+                if (!timeExpiredCalledRef.current) {
+                    timeExpiredCalledRef.current = true;
+                    onTimeExpiredRef.current();
+                }
+            }
+        };
+        intervalRef.current = setInterval(tick, 1000);
+        // Resync immediately when the exam tab becomes visible / regains focus so the
+        // displayed time corrects at once (and auto-submit fires if it already lapsed).
+        const handleResync = () => {
+            if (document.visibilityState === 'visible')
+                tick();
+        };
+        document.addEventListener('visibilitychange', handleResync);
+        window.addEventListener('focus', handleResync);
+        return () => {
+            if (intervalRef.current) {
+                clearInterval(intervalRef.current);
+                intervalRef.current = null;
+            }
+            document.removeEventListener('visibilitychange', handleResync);
+            window.removeEventListener('focus', handleResync);
+        };
+    }, [store.isInitialized]);
+    const warningLevel = getWarningLevel(store.remainingSeconds, effectiveThresholds);
+    return {
+        remainingSeconds: store.remainingSeconds,
+        warningLevel,
+    };
+}

package/dist/components/exams/take/hooks/useProctoringCamera.js

@@ -1 +1,118 @@
-import{useEffect as e,useRef as r,useState as t}from"react";export function useProctoringCamera({api:n,attemptId:a,intervalMs:o=1e4,enabled:c=!1}){const[i,u]=t(!1),[l,s]=t(null),[d,m]=t(0),p=r(null),h=r(null),g=r(null);return e(()=>{if("undefined"==typeof window)return;if(!c)return;let e=!0;return(async()=>{try{const r=await navigator.mediaDevices.getUserMedia({video:{facingMode:"user"},audio:!1});if(!e)return void r.getTracks().forEach(e=>e.stop());h.current=r;const t=document.createElement("video");t.srcObject=r,t.muted=!0,t.playsInline=!0,t.onloadedmetadata=()=>{e&&(t.play().catch(console.error),u(!0),s(null))},p.current=t}catch(r){console.error("Camera permission denied or error:",r),e&&(u(!1),s(r.message||"Camera access denied"))}})(),()=>{e=!1,h.current&&(h.current.getTracks().forEach(e=>e.stop()),h.current=null),u(!1),p.current=null}},[c]),e(()=>{if(!a||!i||!p.current)return void(g.current&&(clearInterval(g.current),g.current=null));return g.current=setInterval(async()=>{const e=p.current;if(e&&e.videoWidth)try{const r=document.createElement("canvas");r.width=e.videoWidth,r.height=e.videoHeight;const t=r.getContext("2d");if(!t)return;t.drawImage(e,0,0,r.width,r.height),r.toBlob(async e=>{if(e)try{await(n.uploadProctoringSnapshot?.({attemptId:a,imageBlob:e})),m(e=>e+1)}catch(e){console.error("Failed to upload proctoring snapshot:",e)}},"image/jpeg",.6)}catch(e){console.error("Error in capture process:",e)}},o),()=>{g.current&&(clearInterval(g.current),g.current=null)}},[n,a,i,o]),{isCameraActive:i,cameraError:l,snapshotCount:d}}
+import { useEffect, useRef, useState } from 'react';
+export function useProctoringCamera({ api, attemptId, intervalMs = 10000, enabled = false, }) {
+    const [isCameraActive, setIsCameraActive] = useState(false);
+    const [cameraError, setCameraError] = useState(null);
+    const [snapshotCount, setSnapshotCount] = useState(0);
+    const videoRef = useRef(null);
+    const streamRef = useRef(null);
+    const intervalRef = useRef(null);
+    // Initialize camera and video element
+    useEffect(() => {
+        // Only run on client
+        if (typeof window === 'undefined')
+            return;
+        // Gate on the host-provided flag instead of a host env var.
+        if (!enabled) {
+            return;
+        }
+        let isMounted = true;
+        const startCamera = async () => {
+            try {
+                const stream = await navigator.mediaDevices.getUserMedia({
+                    video: { facingMode: 'user' },
+                    audio: false,
+                });
+                if (!isMounted) {
+                    // If unmounted while requesting permission, stop tracks immediately
+                    stream.getTracks().forEach((track) => track.stop());
+                    return;
+                }
+                streamRef.current = stream;
+                // Create a hidden video element to process frames
+                const video = document.createElement('video');
+                video.srcObject = stream;
+                video.muted = true; // Required to autoplay without user interaction in some browsers
+                video.playsInline = true;
+                video.onloadedmetadata = () => {
+                    if (isMounted) {
+                        video.play().catch(console.error);
+                        setIsCameraActive(true);
+                        setCameraError(null);
+                    }
+                };
+                videoRef.current = video;
+            }
+            catch (err) {
+                console.error('Camera permission denied or error:', err);
+                if (isMounted) {
+                    setIsCameraActive(false);
+                    setCameraError(err.message || 'Camera access denied');
+                }
+            }
+        };
+        startCamera();
+        return () => {
+            isMounted = false;
+            if (streamRef.current) {
+                streamRef.current.getTracks().forEach((track) => track.stop());
+                streamRef.current = null;
+            }
+            setIsCameraActive(false);
+            videoRef.current = null;
+        };
+    }, [enabled]);
+    // Set up the interval for taking snapshots
+    useEffect(() => {
+        // Need valid attemptId, active camera, and a valid video element
+        if (!attemptId || !isCameraActive || !videoRef.current) {
+            if (intervalRef.current) {
+                clearInterval(intervalRef.current);
+                intervalRef.current = null;
+            }
+            return;
+        }
+        const captureAndUpload = async () => {
+            const video = videoRef.current;
+            if (!video || !video.videoWidth)
+                return;
+            try {
+                const canvas = document.createElement('canvas');
+                canvas.width = video.videoWidth;
+                canvas.height = video.videoHeight;
+                const ctx = canvas.getContext('2d');
+                if (!ctx)
+                    return;
+                ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+                // Convert to Blob (JPEG for smaller size, 60% quality is usually enough for proctoring)
+                canvas.toBlob(async (blob) => {
+                    if (!blob)
+                        return;
+                    try {
+                        await api.uploadProctoringSnapshot?.({ attemptId, imageBlob: blob });
+                        setSnapshotCount((prev) => prev + 1);
+                    }
+                    catch (err) {
+                        console.error('Failed to upload proctoring snapshot:', err);
+                        // don't block or alert the user on failure
+                    }
+                }, 'image/jpeg', 0.6);
+            }
+            catch (err) {
+                console.error('Error in capture process:', err);
+            }
+        };
+        // Important: run interval
+        intervalRef.current = setInterval(captureAndUpload, intervalMs);
+        return () => {
+            if (intervalRef.current) {
+                clearInterval(intervalRef.current);
+                intervalRef.current = null;
+            }
+        };
+    }, [api, attemptId, isCameraActive, intervalMs]);
+    return {
+        isCameraActive,
+        cameraError,
+        snapshotCount,
+    };
+}

package/dist/components/exams/take/hooks/useProctoringSnapshot.js

@@ -1 +1,76 @@
-"use client";import{useEffect as t,useRef as e}from"react";export function useProctoringSnapshot({api:r,attemptId:n,enabled:a,intervalMs:i=6e4,onError:o}){const c=e(null),s=e(!1),u=e(o);return u.current=o,t(()=>{if(!a||!n||!r.uploadProctoringSnapshot)return;if("undefined"==typeof navigator||!navigator.mediaDevices?.getUserMedia)return;let t=null,e=null,o=!1;const d=async()=>{const t=c.current;if(!t||0===t.videoWidth||!r.uploadProctoringSnapshot)return;const e=document.createElement("canvas");e.width=t.videoWidth,e.height=t.videoHeight;const a=e.getContext("2d");if(!a)return;a.drawImage(t,0,0,e.width,e.height);const i=await new Promise(t=>e.toBlob(t,"image/jpeg",.7));if(i)try{await r.uploadProctoringSnapshot({attemptId:n,imageBlob:i})}catch(t){u.current?.(t)}};return(async()=>{try{if(t=await navigator.mediaDevices.getUserMedia({video:!0,audio:!1}),o)return void t.getTracks().forEach(t=>t.stop());c.current&&(c.current.srcObject=t,await c.current.play().catch(()=>{})),s.current=!0,d(),e=setInterval(()=>{d()},i)}catch(t){u.current?.(t)}})(),()=>{o=!0,s.current=!1,e&&clearInterval(e),t&&t.getTracks().forEach(t=>t.stop())}},[r,n,a,i]),{videoRef:c,isActiveRef:s}}
+'use client';
+import { useEffect, useRef } from 'react';
+/** Default cadence for proctoring snapshots (1 minute). */
+const DEFAULT_INTERVAL_MS = 60000;
+/** JPEG quality used when encoding the captured frame. */
+const SNAPSHOT_QUALITY = 0.7;
+/**
+ * Captures periodic webcam snapshots and uploads them for proctoring. Owns the
+ * camera stream lifecycle (request on enable, stop on cleanup) and encodes
+ * frames off a hidden canvas, mirroring the host app's proctoring loop.
+ */
+export function useProctoringSnapshot({ api, attemptId, enabled, intervalMs = DEFAULT_INTERVAL_MS, onError, }) {
+    const videoRef = useRef(null);
+    const isActiveRef = useRef(false);
+    const onErrorRef = useRef(onError);
+    onErrorRef.current = onError;
+    useEffect(() => {
+        if (!enabled || !attemptId || !api.uploadProctoringSnapshot)
+            return undefined;
+        if (typeof navigator === 'undefined' || !navigator.mediaDevices?.getUserMedia)
+            return undefined;
+        let stream = null;
+        let timer = null;
+        let cancelled = false;
+        const captureAndUpload = async () => {
+            const video = videoRef.current;
+            if (!video || video.videoWidth === 0 || !api.uploadProctoringSnapshot)
+                return;
+            const canvas = document.createElement('canvas');
+            canvas.width = video.videoWidth;
+            canvas.height = video.videoHeight;
+            const context = canvas.getContext('2d');
+            if (!context)
+                return;
+            context.drawImage(video, 0, 0, canvas.width, canvas.height);
+            const blob = await new Promise((resolve) => canvas.toBlob(resolve, 'image/jpeg', SNAPSHOT_QUALITY));
+            if (!blob)
+                return;
+            try {
+                await api.uploadProctoringSnapshot({ attemptId, imageBlob: blob });
+            }
+            catch (error) {
+                onErrorRef.current?.(error);
+            }
+        };
+        const start = async () => {
+            try {
+                stream = await navigator.mediaDevices.getUserMedia({ video: true, audio: false });
+                if (cancelled) {
+                    stream.getTracks().forEach((track) => track.stop());
+                    return;
+                }
+                if (videoRef.current) {
+                    videoRef.current.srcObject = stream;
+                    await videoRef.current.play().catch(() => undefined);
+                }
+                isActiveRef.current = true;
+                void captureAndUpload();
+                timer = setInterval(() => void captureAndUpload(), intervalMs);
+            }
+            catch (error) {
+                onErrorRef.current?.(error);
+            }
+        };
+        void start();
+        return () => {
+            cancelled = true;
+            isActiveRef.current = false;
+            if (timer)
+                clearInterval(timer);
+            if (stream)
+                stream.getTracks().forEach((track) => track.stop());
+        };
+    }, [api, attemptId, enabled, intervalMs]);
+    return { videoRef, isActiveRef };
+}