easyproctor-hml 2.7.13 → 2.8.0

package/new-flow/checkers/DeviceCheckerUI.d.ts

@@ -12,6 +12,8 @@ export declare class DeviceCheckerUI {
     videoOptions: ProctoringVideoOptions;
     cameraRecorder: CameraRecorder;
     volumeMeter: VolumeMeter | undefined;
+    private autoConfirmTimer;
+    private autoConfirmSeconds;
     constructor(options: ProctoringSessionOptions | undefined, _videoOptions: ProctoringVideoOptions);
     checkDevicesInterface(): void;
     setSelectOption(options: ProctoringSessionOptions, changeSelectedDevice: (arg0: {
@@ -29,6 +31,15 @@ export declare class DeviceCheckerUI {
         }): any;
     }): Promise<void>;
     closeModal(): void;
+    verifyAutoConfirm(status: {
+        allowedResolution: boolean;
+        allowedPositionFace: boolean;
+        allowedAmbient: boolean;
+        allowedMicrophone: boolean;
+        allowedSpyScan: boolean | null;
+    }): void;
+    private startAutoConfirm;
+    private stopAutoConfirm;
     modalActions(closeCheckDevices: {
         (): Promise<void>;
         (): void;

package/new-flow/chunk/BackgroundUploadService.d.ts

@@ -0,0 +1,38 @@
+import { BackendService } from "../backend/BackendService";
+import { ChunkStorageService } from "./ChunkStorageService";
+export interface BackgroundUploadConfig {
+    pollInterval?: number;
+    maxRetries?: number;
+    baseRetryDelay?: number;
+    cleanAfterUpload?: boolean;
+}
+export declare class BackgroundUploadService {
+    private readonly config;
+    private readonly chunkStorage;
+    private readonly backend;
+    private readonly proctoringId;
+    private readonly token;
+    private pollTimer;
+    private isProcessing;
+    private isRunning;
+    private retryCount;
+    private sessionUrl;
+    private currentOffset;
+    private totalBytesPurged;
+    private readonly STORAGE_KEY_PREFIX;
+    private readonly GCS_CHUNK_SIZE;
+    onChunkUploaded?: (chunkId: number, chunkIndex: number) => void;
+    onUploadError?: (chunkId: number, error: any) => void;
+    constructor(proctoringId: string, token: string, backend: BackendService, chunkStorage: ChunkStorageService, config?: BackgroundUploadConfig);
+    private loadSessionState;
+    private saveSessionState;
+    private clearSessionState;
+    start(): void;
+    stop(): void;
+    flush(): Promise<void>;
+    private syncOffset;
+    private processQueue;
+    private uploadData;
+    static recoverPendingUploads(backend: BackendService, token: string): Promise<string[]>;
+    private sleep;
+}

package/new-flow/chunk/ChunkStorageService.d.ts

@@ -0,0 +1,25 @@
+export interface VideoChunk {
+    id?: number;
+    proctoringId: string;
+    chunkIndex: number;
+    arrayBuffer: ArrayBuffer;
+    timestamp: number;
+    uploaded: number;
+    mimeType: string;
+}
+export declare class ChunkStorageService {
+    private static readonly DB_NAME;
+    private static readonly DB_VERSION;
+    private static readonly STORE_NAME;
+    private db;
+    connect(): Promise<IDBDatabase>;
+    saveChunk(chunk: Omit<VideoChunk, "id">): Promise<number>;
+    getPendingChunks(proctoringId: string): Promise<VideoChunk[]>;
+    getAllChunks(proctoringId: string): Promise<VideoChunk[]>;
+    markAsUploaded(chunkId: number): Promise<void>;
+    clearUploadedChunks(proctoringId: string): Promise<void>;
+    clearAllChunks(proctoringId: string): Promise<void>;
+    hasAnyPendingChunks(): Promise<boolean>;
+    getPendingProctoringIds(): Promise<string[]>;
+    close(): void;
+}

package/new-flow/recorders/CameraRecorder.d.ts

@@ -40,6 +40,17 @@ export declare class CameraRecorder implements IRecorder {
     private videoElement;
     private duration;
     stopped: boolean;
+    private static readonly CHUNK_TIMESLICE_MS;
+    private static readonly LS_SESSION_KEY;
+    private chunkStorage;
+    private backgroundUpload;
+    private chunkIndex;
+    private pendingChunkSaves;
+    onSessionInterrupted?: () => void;
+    onVisibilityRestored?: () => void;
+    private boundVisibilityHandler;
+    private boundPageHideHandler;
+    private get isChunkEnabled();
     constructor(options: {
         cameraId?: string;
         microphoneId?: string;
@@ -58,6 +69,17 @@ export declare class CameraRecorder implements IRecorder {
     getStartTime: () => any;
     getDuration: () => any;
     setProctoringId(proctoringId: string): void;
+    private persistSessionState;
+    private clearSessionState;
+    static checkForActiveSession(): {
+        proctoringId: string;
+        status: string;
+        timestamp: number;
+    } | null;
+    private setupLifecycleListeners;
+    private removeLifecycleListeners;
+    private handleVisibilityChange;
+    private handlePageHide;
     initializeDetectors(): Promise<void>;
     configImageCapture(): void;
     currentRetries: number;
@@ -68,6 +90,7 @@ export declare class CameraRecorder implements IRecorder {
     attachAndWarmup(stream: MediaStream): Promise<void>;
     startRecording(): Promise<void>;
     stopRecording(): Promise<void>;
+    private handleNewChunk;
     pauseRecording(): Promise<void>;
     resumeRecording(): Promise<void>;
     getCurrentImageBase64(): Promise<string>;
@@ -79,6 +102,4 @@ export declare class CameraRecorder implements IRecorder {
     download(file: File): void;
     saveOnSession(session: ProctoringSession): Promise<void>;
     getFile(file: string, name: string, type: string): Promise<File>;
-    noiseWait: number;
-    private onNoiseDetected;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easyproctor-hml",
-  "version": "2.7.13",
+  "version": "2.8.0",
   "description": "Modulo web de gravação do EasyProctor",
   "main": "./index.js",
   "module": "./esm/index.js",

package/proctoring/options/ProctoringOptions.d.ts

@@ -17,5 +17,6 @@ export interface ProctoringSessionOptions {
         width: number;
         height: number;
     };
+    auto?: boolean;
 }
 export declare const getDefaultProctoringOptions: ProctoringSessionOptions;

package/proctoring/proctoring.d.ts

@@ -41,6 +41,7 @@ export declare class Proctoring {
     private readonly repository;
     private readonly repositoryDevices;
     private extension;
+    private extensionEasycatcher;
     private deviceData;
     private paramsConfig;
     private proctoringId;
@@ -100,4 +101,8 @@ export declare class Proctoring {
         audioStream?: MediaStream;
         _screenStream: MediaStream | undefined;
     }>;
+    private isChallengeRunning;
+    private challengeId;
+    startChallenge(templateId: string): Promise<void>;
+    stopChallenge(): Promise<void>;
 }

package/proctoring/useProctoring.d.ts

@@ -5,6 +5,8 @@ export declare function useProctoring(proctoringOptions: ProctoringContext, envi
     login: () => Promise<void>;
     start: (parameters: any, videoOptions: any) => Promise<import("../dtos/StartProctoringResponse").default>;
     finish: (options?: import("./proctoring").ProctoringFinisherOptions) => Promise<void>;
+    startChallenge: (templateId: string) => Promise<void>;
+    stopChallenge: () => Promise<void>;
     onFocus: (cb: () => void) => Promise<void>;
     onLostFocus: (cb: () => void) => Promise<void>;
     onChangeDevices: (options?: import("./proctoring").ProctoringChangeDevicesOptions) => Promise<void>;