easyproctor 2.5.2 → 2.5.3

package/index.js

@@ -26076,6 +26076,14 @@ var BaseDetection = class {
         return "Face n\xE3o centralizada, mova-se para cima";
       case "wrong_face_position_move_bottom_detected":
         return "Face n\xE3o centralizada, mova-se para baixo";
+      case "face_turned_left_detected":
+        return "Face virada para a esquerda, centralize-a";
+      case "face_turned_right_detected":
+        return "Face virada para a direita, centralize-a";
+      case "face_turned_up_detected":
+        return "Face virada para cima, centralize-a";
+      case "face_turned_down_detected":
+        return "Face virada para baixo, centralize-a";
       default:
         return description;
     }
@@ -26106,7 +26114,14 @@ function buildVideoPreview() {
 // src/modules/faceDetection.ts
 var FaceDetection = class extends BaseDetection {
   constructor(options, paramsConfig, classVideo = "videoPreviewFrameDetection", classDiv = "liveViewFrameDetection") {
-    super("FaceDetector", `https://storage.googleapis.com/mediapipe-models/face_detector/blaze_face_short_range/float16/1/blaze_face_short_range.tflite`, options, paramsConfig, classVideo, classDiv);
+    super(
+      "FaceDetector",
+      `https://storage.googleapis.com/mediapipe-models/face_detector/blaze_face_short_range/float16/1/blaze_face_short_range.tflite`,
+      options,
+      paramsConfig,
+      classVideo,
+      classDiv
+    );
     this.emmitedPositionAlert = false;
     this.emmitedFaceAlert = false;
   }
@@ -26252,8 +26267,8 @@ var FaceDetection = class extends BaseDetection {
         for (const keypoint of detection.keypoints) {
           const keypointEl = document.createElement("span");
           keypointEl.className = "key-point";
-          let kpX = keypoint.x < 2 ? keypoint.x * videoElement.videoWidth : keypoint.x;
-          let kpY = keypoint.y < 2 ? keypoint.y * videoElement.videoHeight : keypoint.y;
+          const kpX = keypoint.x < 2 ? keypoint.x * videoElement.videoWidth : keypoint.x;
+          const kpY = keypoint.y < 2 ? keypoint.y * videoElement.videoHeight : keypoint.y;
           const mirroredKpX = videoElement.videoWidth - kpX;
           const screenX = mirroredKpX * scaleX;
           const screenY = kpY * scaleY;
@@ -26292,55 +26307,87 @@ var FaceDetection = class extends BaseDetection {
       }
     }
     if (result.detections.length === 0) return;
-    let face = result.detections[0].boundingBox;
-    let video = document.getElementById(this.classVideo);
+    let failedFacePosition = false;
+    const video = document.getElementById(this.classVideo);
     const imageWidth = video.videoWidth;
     const imageHeight = video.videoHeight;
-    let failedFacePosition = false;
+    const detection = result.detections[0];
+    const face = detection.boundingBox;
+    const keypoints = detection.keypoints;
+    const rightEye = keypoints[0];
+    const leftEye = keypoints[1];
+    const mouth = keypoints[3];
+    const rightEar = keypoints[4];
+    const leftEar = keypoints[5];
+    const nose = keypoints[2];
     if (imageWidth > imageHeight) {
       if (face.height / imageHeight > 0.7) {
-        !this.emmitedPositionAlert && this.handleAlert("wrong_face_size_detected", "position_detection_on_stream");
+        !this.emmitedPositionAlert && this.handleAlert(
+          "wrong_face_size_detected",
+          "position_detection_on_stream"
+        );
         failedFacePosition = true;
         this.emmitedPositionAlert = true;
       } else if (face.width / imageWidth > 0.7) {
-        !this.emmitedPositionAlert && this.handleAlert("wrong_face_size_detected", "position_detection_on_stream");
+        !this.emmitedPositionAlert && this.handleAlert(
+          "wrong_face_size_detected",
+          "position_detection_on_stream"
+        );
         this.emmitedPositionAlert = true;
         failedFacePosition = true;
       }
     }
-    let start = [face.originX, face.originY];
-    let end = [face.originX + face.width, face.originY + face.height];
+    const start = [face.originX, face.originY];
+    const end = [face.originX + face.width, face.originY + face.height];
     if (start[0] < 0.1 * face.width || start[1] < 0.2 * face.height || end[0] > imageWidth - 0.1 * face.width || end[1] > imageHeight - 5) {
-      !this.emmitedPositionAlert && this.handleAlert("wrong_face_position_edge_detected", "position_detection_on_stream");
+      !this.emmitedPositionAlert && this.handleAlert(
+        "wrong_face_position_edge_detected",
+        "position_detection_on_stream"
+      );
       this.emmitedPositionAlert = true;
       failedFacePosition = true;
     }
-    let leftGap = start[0];
-    let rightGap = imageWidth - end[0];
-    let topGap = start[1];
-    let bottomGap = imageHeight - end[1];
+    const leftGap = start[0];
+    const rightGap = imageWidth - end[0];
+    const topGap = start[1];
+    const bottomGap = imageHeight - end[1];
     if (leftGap > 2 * rightGap) {
-      !this.emmitedPositionAlert && this.handleAlert("wrong_face_position_move_right_detected", "position_detection_on_stream");
+      !this.emmitedPositionAlert && this.handleAlert(
+        "wrong_face_position_move_right_detected",
+        "position_detection_on_stream"
+      );
       this.emmitedPositionAlert = true;
       failedFacePosition = true;
     }
     if (topGap > 4 * bottomGap) {
-      !this.emmitedPositionAlert && this.handleAlert("wrong_face_position_move_top_detected", "position_detection_on_stream");
+      !this.emmitedPositionAlert && this.handleAlert(
+        "wrong_face_position_move_top_detected",
+        "position_detection_on_stream"
+      );
       this.emmitedPositionAlert = true;
       failedFacePosition = true;
     }
     if (rightGap > 2 * leftGap) {
-      !this.emmitedPositionAlert && this.handleAlert("wrong_face_position_move_left_detected", "position_detection_on_stream");
+      !this.emmitedPositionAlert && this.handleAlert(
+        "wrong_face_position_move_left_detected",
+        "position_detection_on_stream"
+      );
       this.emmitedPositionAlert = true;
       failedFacePosition = true;
     }
     if (bottomGap > 3 * topGap) {
-      !this.emmitedPositionAlert && this.handleAlert("wrong_face_position_move_bottom_detected", "position_detection_on_stream");
+      !this.emmitedPositionAlert && this.handleAlert(
+        "wrong_face_position_move_bottom_detected",
+        "position_detection_on_stream"
+      );
       this.emmitedPositionAlert = true;
       failedFacePosition = true;
     }
     if (failedFacePosition == false) {
-      this.emmitedPositionAlert && this.handleOk("ok_position_face_detected", "position_detection_on_stream");
+      this.emmitedPositionAlert && this.handleOk(
+        "ok_position_face_detected",
+        "position_detection_on_stream"
+      );
       this.emmitedPositionAlert = false;
     }
   }
@@ -29869,12 +29916,12 @@ var BackendService = class {
     });
     return result.data;
   }
-  async verifyFace(proctoringId2, faceImage) {
+  async verifyFace(proctoringId2, faceImage, retry) {
     const result = await this.makeRequestAxios({
       path: `/Realtime/verify-face`,
       method: "POST",
       jwt: this.token,
-      body: { "proctoringId": proctoringId2, "base64": faceImage }
+      body: { "proctoringId": proctoringId2, "base64": faceImage, "retry": retry }
     });
     return result.data;
   }
@@ -30750,7 +30797,6 @@ var CameraRecorder = class {
         noiseLimit: 40
       },
       imageBehaviourParameters: {
-        frames: 40,
         useUploadImage: true,
         uploadInterval: 20,
         saveVideo: true
@@ -30762,7 +30808,6 @@ var CameraRecorder = class {
       }
     };
     // private imageParams: ImageParameters = {
-    //     frames: 40,
     //     useUploadImage: true,
     //     uploadInterval: 20,
     //     saveVideo: true
@@ -31671,8 +31716,20 @@ var DeviceCheckerUI = class {
     );
     checkmark_FacePosition.appendChild(checkmark_stem_FacePosition);
     checkmark_FacePosition.appendChild(checkmark_kick_FacePosition);
+    const info_FacePosition = document.createElement("span");
+    const info_stem_FacePosition = document.createElement("div");
+    const info_kick_FacePosition = document.createElement("div");
+    info_FacePosition.style.marginLeft = "10px";
+    info_FacePosition.setAttribute("class", "info");
+    info_FacePosition.setAttribute("id", "info_FacePosition");
+    info_FacePosition.style.display = "none";
+    info_stem_FacePosition.setAttribute("class", "info_stem");
+    info_kick_FacePosition.setAttribute("class", "info_kick");
+    info_FacePosition.appendChild(info_stem_FacePosition);
+    info_FacePosition.appendChild(info_kick_FacePosition);
     alertDivFacePosition.appendChild(checkmark_FacePosition);
     alertDivFacePosition.appendChild(facePositionAlert);
+    alertDivFacePosition.appendChild(info_FacePosition);
     const alertDivAmbientVerify = document.createElement("div");
     alertDivAmbientVerify.setAttribute("class", "alert-div");
     alertDivAmbientVerify.setAttribute("id", "alertDivAmbientVerify");
@@ -32003,6 +32060,8 @@ var DeviceCheckerUI = class {
   realtimeAlertsUI(response) {
     const facePositionAlert = document.getElementById("facePositionAlert");
     const ambientVerifyAlert = document.getElementById("ambientVerifyAlert");
+    const alertDivFacePosition = document.getElementById("alertDivFacePosition");
+    const info_FacePosition = document.getElementById("info_FacePosition");
     const checkmark_FacePosition = document.getElementById("checkmark_FacePosition");
     const checkmark_stem_FacePosition = document.getElementById("checkmark_stem_FacePosition");
     const checkmark_kick_FacePosition = document.getElementById("checkmark_kick_FacePosition");
@@ -32013,6 +32072,8 @@ var DeviceCheckerUI = class {
     if (response.status === "OK") {
       facePositionAlert && (facePositionAlert.style.color = "#16A34A");
       ambientVerifyAlert && (ambientVerifyAlert.style.color = "#16A34A");
+      alertDivFacePosition && alertDivFacePosition.setAttribute("title", ``);
+      info_FacePosition && (info_FacePosition.style.display = "none");
       alertDivAmbientVerify && alertDivAmbientVerify.setAttribute("title", ``);
       if (checkmark_FacePosition) {
         checkmark_FacePosition.setAttribute("class", "checkmark");
@@ -32027,6 +32088,8 @@ var DeviceCheckerUI = class {
     } else {
       if (checkmark_FacePosition && (response.type === "position_detection_on_stream" || response.type === "face_detection_on_stream")) {
         facePositionAlert && (facePositionAlert.style.color = "#FF0000");
+        info_FacePosition && (info_FacePosition.style.display = "block");
+        alertDivFacePosition && alertDivFacePosition.setAttribute("title", response.description);
         checkmark_FacePosition.setAttribute("class", "checkmark_error");
         checkmark_stem_FacePosition.setAttribute("class", "checkmark_stem_error");
         checkmark_kick_FacePosition.setAttribute("class", "checkmark_kick_error");
@@ -33137,64 +33200,186 @@ var ProctoringUploader = class {
 var AlertRecorder = class {
   constructor(options, optionsProctoring) {
     this.alerts = [];
+    // Variáveis para controle de inatividade
+    this.lastActivityTime = Date.now();
+    this.IDLE_THRESHOLD_MS = 3e4;
+    // ==========================================
+    // HANDLERS (Funções Arrow para preservar o 'this')
+    // ==========================================
+    // 1. LOST / RETURN FOCUS
+    this.handleLostFocus = () => {
+      if (this.getRelativeTime() > 1e4) {
+        const alertPayload = {
+          begin: this.getRelativeTime(),
+          end: 0,
+          alert: 25 /* FocusOff */,
+          type: 3 /* Screen */
+        };
+        this.onLostFocusCallback(alertPayload);
+        this.alerts.push(alertPayload);
+      }
+    };
+    this.handleReturnFocus = () => {
+      const lastAlert = this.alerts[this.alerts.length - 1];
+      if (lastAlert) {
+        this.onFocusCallback({
+          begin: lastAlert.begin,
+          end: this.getRelativeTime(),
+          alert: 25 /* FocusOff */,
+          type: 3 /* Screen */
+        });
+        lastAlert.end = this.getRelativeTime();
+      }
+    };
+    // 2. SPLIT SCREEN DETECTION
+    this.handleResize = () => {
+      clearTimeout(this.resizeTimeout);
+      this.resizeTimeout = setTimeout(() => {
+        const screenWidth = window.screen.availWidth;
+        const windowWidth = window.outerWidth;
+        if (windowWidth < screenWidth * 0.85) {
+          const msg = `Split Screen Detectado: Janela ocupa ${(windowWidth / screenWidth * 100).toFixed(0)}% da tela`;
+          this.createAlert(200 /* System */, 3 /* Screen */, msg);
+          this.onRealtimeAlertCallback && this.onRealtimeAlertCallback({
+            status: "ALERT",
+            description: msg,
+            type: "split_screen"
+          });
+        }
+      }, 1e3);
+    };
+    // 3. DETECÇÃO DE INATIVIDADE (NO INPUT)
+    this.handleUserActivity = (e3) => {
+      this.lastActivityTime = Date.now();
+      console.log("\u{1F449} handleUserActivity", e3);
+    };
+    // 5. CLIPBOARD HANDLERS 
+    this.handleCopy = (e3) => {
+      e3.preventDefault();
+      const msg = "Tentativa de Copiar (Clipboard)";
+      this.createAlert(100 /* ForbiddenAction */, 6 /* System */, msg);
+      this.onRealtimeAlertCallback && this.onRealtimeAlertCallback({
+        status: "ALERT",
+        description: msg,
+        type: "clipboard_copy"
+      });
+    };
+    this.handleCut = (e3) => {
+      e3.preventDefault();
+      const msg = "Tentativa de Recortar (Clipboard)";
+      this.createAlert(100 /* ForbiddenAction */, 6 /* System */, msg);
+      this.onRealtimeAlertCallback && this.onRealtimeAlertCallback({
+        status: "ALERT",
+        description: msg,
+        type: "clipboard_cut"
+      });
+    };
+    this.handlePaste = (e3) => {
+      e3.preventDefault();
+      const msg = "Tentativa de Colar (Clipboard)";
+      this.createAlert(100 /* ForbiddenAction */, 6 /* System */, msg);
+      this.onRealtimeAlertCallback && this.onRealtimeAlertCallback({
+        status: "ALERT",
+        description: msg,
+        type: "clipboard_paste"
+      });
+    };
     this.onLostFocusCallback = options.onLostFocusCallback;
     this.onFocusCallback = options.onFocusCallback;
+    this.onRealtimeAlertCallback = options.onRealtimeAlertCallback;
     this.optionsProctoring = optionsProctoring;
   }
   async startRecording() {
     this.startTime = new Date(Date.now());
-    if (this.optionsProctoring.captureScreen) {
-      window.addEventListener("blur", () => this.onLostFocus());
-      window.addEventListener("focus", () => this.onReturnFocus());
-    }
+    this.alerts = [];
+    this.attachListeners();
   }
   async pauseRecording() {
-    window.removeEventListener("blur", () => this.onLostFocus());
-    window.removeEventListener("focus", () => this.onReturnFocus());
+    this.detachListeners();
   }
   async resumeRecording() {
-    if (this.optionsProctoring.captureScreen) {
-      window.addEventListener("blur", () => this.onLostFocus());
-      window.addEventListener("focus", () => this.onReturnFocus());
-    }
+    this.attachListeners();
   }
   async stopRecording() {
-    window.removeEventListener("blur", () => this.onLostFocus());
-    window.removeEventListener("focus", () => this.onReturnFocus());
+    this.detachListeners();
   }
   async saveOnSession(session) {
     this.alerts.forEach((alert) => {
       session.addAlert(alert);
     });
   }
-  onLostFocus() {
-    var _a2;
-    if (Date.now() - ((_a2 = this.startTime) == null ? void 0 : _a2.getTime()) > 1e4) {
-      this.onLostFocusCallback({
-        begin: Date.now() - this.startTime.getTime(),
-        end: 0,
-        alert: 25 /* FocusOff */,
-        type: 3 /* Screen */
-      });
-      this.alerts.push({
-        begin: Date.now() - this.startTime.getTime(),
-        end: 0,
-        alert: 25 /* FocusOff */,
-        type: 3 /* Screen */
-      });
-    }
+  // ==========================================
+  // GERENCIAMENTO DE LISTENERS
+  // ==========================================
+  attachListeners() {
+    if (this.optionsProctoring.captureScreen) {
+      window.addEventListener("blur", this.handleLostFocus);
+      window.addEventListener("focus", this.handleReturnFocus);
+      window.addEventListener("resize", this.handleResize);
+      window.document.addEventListener("copy", this.handleCopy);
+      window.document.addEventListener("cut", this.handleCut);
+      window.document.addEventListener("paste", this.handlePaste);
+    }
+  }
+  detachListeners() {
+    window.removeEventListener("blur", this.handleLostFocus);
+    window.removeEventListener("focus", this.handleReturnFocus);
+    window.removeEventListener("resize", this.handleResize);
+    window.document.removeEventListener("copy", this.handleCopy);
+    window.document.removeEventListener("cut", this.handleCut);
+    window.document.removeEventListener("paste", this.handlePaste);
+  }
+  // private startIdleChecker() {
+  //   this.stopIdleChecker(); // Garante que não tenha duplicação
+  //   this.idleCheckInterval = setInterval(() => {
+  //       const idleTime = Date.now() - this.lastActivityTime;
+  //       if (idleTime > this.IDLE_THRESHOLD_MS) {
+  //           // Verifica se já não mandamos esse alerta recentemente para não floodar
+  //           const lastAlert = this.alerts[this.alerts.length - 1];
+  //           // Se o último alerta não foi de inatividade ou foi há muito tempo, cria novo
+  //           if (!lastAlert || lastAlert.alert !== AlertCategory.ForbiddenAction || (this.getRelativeTime() - lastAlert.begin > 5000)) {
+  //               const msg = "Usuário inativo por muito tempo";
+  //               // Assumindo ForbiddenAction ou outra categoria adequada
+  //               this.createAlert(AlertCategory.ForbiddenAction, AlertType.System, msg);
+  //               this.onRealtimeAlertCallback && this.onRealtimeAlertCallback({
+  //                   status: 'ALERT',
+  //                   description: msg,
+  //                   type: 'user_idle'
+  //               });
+  //           }
+  //       }
+  //   }, 5000); // Checa a cada 5 segundos
+  // }
+  // private stopIdleChecker() {
+  //   if (this.idleCheckInterval) {
+  //       clearInterval(this.idleCheckInterval);
+  //       this.idleCheckInterval = null;
+  //   }
+  // }
+  // 4. BACKGROUND EVENTS (Eventos disparados manualmente)
+  addBackgroundEvent(description, category = 200 /* System */) {
+    this.createAlert(category, 6 /* System */, description);
+    this.onRealtimeAlertCallback && this.onRealtimeAlertCallback({
+      status: "ALERT",
+      description,
+      type: "background_event"
+    });
   }
-  onReturnFocus() {
-    const lastAlert = this.alerts[this.alerts.length - 1];
-    if (lastAlert) {
-      this.onFocusCallback({
-        begin: lastAlert.begin,
-        end: Date.now() - this.startTime.getTime(),
-        alert: 25 /* FocusOff */,
-        type: 3 /* Screen */
-      });
-      lastAlert.end = Date.now() - this.startTime.getTime();
-    }
+  // ==========================================
+  // HELPERS
+  // ==========================================
+  getRelativeTime() {
+    return Date.now() - this.startTime.getTime();
+  }
+  createAlert(category, type, description) {
+    this.alerts.push({
+      begin: this.getRelativeTime(),
+      end: this.getRelativeTime(),
+      // Eventos pontuais começam e terminam no mesmo ms (exceto focus)
+      alert: category,
+      type
+      // description: description // Se sua interface Alert suportar descrição, descomente
+    });
   }
   addAlert({ alert, type }) {
     this.alerts.push({
@@ -36769,7 +36954,6 @@ var Proctoring = class {
         noiseLimit: 40
       },
       imageBehaviourParameters: {
-        frames: 40,
         useUploadImage: true,
         uploadInterval: 20,
         saveVideo: true
@@ -36987,7 +37171,8 @@ var Proctoring = class {
     const alertRecorder = new AlertRecorder(
       {
         onFocusCallback: (response) => this.onFocusAlertRecorderCallback(response),
-        onLostFocusCallback: (response) => this.onLostFocusAlertRecorderCallback(response)
+        onLostFocusCallback: (response) => this.onLostFocusAlertRecorderCallback(response),
+        onRealtimeAlertCallback: (response) => this.onRealtimeAlertsCallback(response)
       },
       options
     );
@@ -37095,11 +37280,23 @@ Navigator: ${JSON.stringify(_navigator2)}`
         startResponse.screenStream = this.allRecorders.screenRecorder.screenStream;
       }
       this.state = "Recording" /* Recording */;
-      setTimeout(async () => {
+      let verifyFirstFaceIntervalCount = 0;
+      let verifyingFace = false;
+      this.verifyFirstFaceInterval = setInterval(async () => {
         if (this.sessionOptions.proctoringType === "REALTIME") {
-          await this.backend.verifyFace(this.proctoringId, await this.allRecorders.cameraRecorder.getCurrentImageBase64());
+          if (verifyingFace) return;
+          verifyingFace = true;
+          verifyFirstFaceIntervalCount++;
+          try {
+            var response = await this.backend.verifyFace(this.proctoringId, await this.allRecorders.cameraRecorder.getCurrentImageBase64(), verifyFirstFaceIntervalCount > 5 ? false : true);
+            verifyingFace = false;
+            clearInterval(this.verifyFirstFaceInterval);
+          } catch (error) {
+            verifyingFace = false;
+            return;
+          }
         }
-      }, 1e3);
+      }, 1500);
       return startResponse;
     } catch (error) {
       console.log(error);
@@ -37236,6 +37433,9 @@ Upload Services: ${uploaderServices}`,
           await this.backend.externalCameraFinish(externalSessionId);
         }
       }
+      if (this.verifyFirstFaceInterval) {
+        clearInterval(this.verifyFirstFaceInterval);
+      }
       this.state = "Stop" /* Stop */;
     } catch (error) {
       await this.cancel();
@@ -37570,12 +37770,12 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
   const photo = new CapturePhoto();
   const login = proctoring.login.bind(proctoring);
   const originalStart = proctoring.start.bind(proctoring);
-  const start = async (parameters2) => {
+  const start = async (parameters2, videoOptions) => {
     const deviceResult = checker.getDeviceCheckResult();
     if (deviceResult) {
       proctoring.setDeviceCheckData(deviceResult);
     }
-    return originalStart(parameters2);
+    return originalStart(parameters2, videoOptions);
   };
   const finish = proctoring.finish.bind(proctoring);
   const pause = proctoring.pause.bind(proctoring);

package/interfaces/ParamsConfig.d.ts

@@ -5,7 +5,6 @@ export type AudioBehaviourParameters = {
     noiseLimit?: number;
 };
 export type ImageBehaviourParameters = {
-    frames?: number;
     useUploadImage?: boolean;
     uploadInterval?: number;
     saveVideo?: boolean;

package/new-flow/backend/BackendService.d.ts

@@ -39,7 +39,7 @@ export declare class BackendService {
     stopChallenge(challengeId: string, body: any): Promise<any>;
     startRealtimeAlert(body: any): Promise<any>;
     stopRealtimeAlert(body: any): Promise<any>;
-    verifyFace(proctoringId: any, faceImage: any): Promise<any>;
+    verifyFace(proctoringId: any, faceImage: any, retry: boolean): Promise<any>;
     getServerHour(token: string): Promise<string>;
     private makeRequest;
     makeRequestAxios<R>(data: {

package/new-flow/proctoring/ProctoringSession.d.ts

@@ -24,7 +24,9 @@ export declare enum AlertCategory {
     PotentialCamera = 32,
     SpyDeviceDisconnected = 33,
     StopSharingScreen = 34,
-    ChangeDevices = 39
+    ChangeDevices = 39,
+    ForbiddenAction = 100,
+    System = 200
 }
 export declare enum FinishRealtimeWarningCategory {
     Face = 0,
@@ -36,7 +38,8 @@ export declare enum AlertType {
     Video = 2,
     Screen = 3,
     Image = 4,
-    Environment = 5
+    Environment = 5,
+    System = 6
 }
 export interface Alert {
     begin: number;

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

@@ -6,18 +6,34 @@ export declare class AlertRecorder implements IRecorder {
     private startTime;
     private onLostFocusCallback;
     private onFocusCallback;
+    private onRealtimeAlertCallback?;
     private optionsProctoring;
+    private lastActivityTime;
+    private idleCheckInterval;
+    private readonly IDLE_THRESHOLD_MS;
+    private resizeTimeout;
     constructor(options: {
         onLostFocusCallback: (response: any) => void;
         onFocusCallback: (response: any) => void;
+        onRealtimeAlertCallback?: (response: any) => void;
     }, optionsProctoring: ProctoringSessionOptions);
     startRecording(): Promise<void>;
     pauseRecording(): Promise<void>;
     resumeRecording(): Promise<void>;
     stopRecording(): Promise<void>;
     saveOnSession(session: ProctoringSession): Promise<void>;
-    private onLostFocus;
-    private onReturnFocus;
+    private attachListeners;
+    private detachListeners;
+    private handleLostFocus;
+    private handleReturnFocus;
+    private handleResize;
+    private handleUserActivity;
+    addBackgroundEvent(description: string, category?: AlertCategory): void;
+    private handleCopy;
+    private handleCut;
+    private handlePaste;
+    private getRelativeTime;
+    private createAlert;
     addAlert({ alert, type }: {
         alert: AlertCategory;
         type: AlertType;

package/package.json

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

package/proctoring/proctoring.d.ts

@@ -55,6 +55,7 @@ export declare class Proctoring {
     private allRecorders;
     private spyCam;
     appChecker: ExternalCameraChecker;
+    private verifyFirstFaceInterval;
     private onStopSharingScreenCallback;
     setOnStopSharingScreenCallback(cb: () => void): void;
     private setOnLostFocusAlertRecorderCallback;

package/proctoring/useProctoring.d.ts

@@ -3,7 +3,7 @@ import enumarateDevices from "../modules/enumarateDevices";
 import { ProctoringContext } from "./proctoring";
 export declare function useProctoring(proctoringOptions: ProctoringContext, enviromentConfig?: string): {
     login: () => Promise<void>;
-    start: (parameters: any) => Promise<import("../dtos/StartProctoringResponse").default>;
+    start: (parameters: any, videoOptions: any) => Promise<import("../dtos/StartProctoringResponse").default>;
     finish: (options?: import("./proctoring").ProctoringFinisherOptions) => Promise<void>;
     onFocus: (cb: () => void) => Promise<void>;
     onLostFocus: (cb: () => void) => Promise<void>;