easyproctor-hml 2.7.0 → 2.7.1

package/index.js

@@ -31648,8 +31648,8 @@ var _ChunkStorageService = class _ChunkStorageService {
   }
 };
 _ChunkStorageService.DB_NAME = "EasyProctorChunksDb";
-/** Incrementado para v2 para recriar índices com tipos numéricos em vez de boolean */
-_ChunkStorageService.DB_VERSION = 2;
+/** v2: índices numéricos; v3: payload como ArrayBuffer em vez de Blob (Safari iOS). */
+_ChunkStorageService.DB_VERSION = 3;
 _ChunkStorageService.STORE_NAME = "chunks";
 var ChunkStorageService = _ChunkStorageService;
 
@@ -31831,32 +31831,41 @@ var BackgroundUploadService = class _BackgroundUploadService {
       console.log(`[BackgroundUpload] ${pendingChunks.length} chunks pendentes encontrados. Modo final: ${isFinal}`);
       let virtualStart = this.totalBytesPurged;
       const chunksWithMeta = allChunks.map((c3) => {
+        const byteLen = c3.arrayBuffer.byteLength;
         const start = virtualStart;
-        const end = start + c3.blob.size - 1;
-        virtualStart += c3.blob.size;
+        const end = start + byteLen - 1;
+        virtualStart += byteLen;
         return { chunk: c3, start, end };
       });
-      let combinedBlobParts = [];
+      const sliceParts = [];
       let lastProcessedChunkId = null;
       let finalChunkIndex = 0;
       let mimeType = pendingChunks[0].mimeType;
       for (const meta of chunksWithMeta) {
         if (this.currentOffset > meta.end) continue;
         const sliceStart = Math.max(0, this.currentOffset - meta.start);
-        const chunkSlice = meta.chunk.blob.slice(sliceStart);
-        combinedBlobParts.push(chunkSlice);
+        const view = new Uint8Array(meta.chunk.arrayBuffer);
+        sliceParts.push(view.subarray(sliceStart));
         lastProcessedChunkId = meta.chunk.id;
         finalChunkIndex = meta.chunk.chunkIndex;
       }
-      if (combinedBlobParts.length === 0 && !isFinal) {
+      if (sliceParts.length === 0 && !isFinal) {
         this.isProcessing = false;
         return;
       }
-      let fullBlob = new Blob(combinedBlobParts, { type: mimeType });
-      let sendableSize = fullBlob.size;
+      const combinedLength = sliceParts.reduce((acc, p3) => acc + p3.length, 0);
+      const combined = new Uint8Array(combinedLength);
+      {
+        let off = 0;
+        for (const p3 of sliceParts) {
+          combined.set(p3, off);
+          off += p3.length;
+        }
+      }
+      let sendableSize = combined.byteLength;
       let totalSizeForHeader = void 0;
       if (!isFinal) {
-        sendableSize = Math.floor(fullBlob.size / this.GCS_CHUNK_SIZE) * this.GCS_CHUNK_SIZE;
+        sendableSize = Math.floor(combined.byteLength / this.GCS_CHUNK_SIZE) * this.GCS_CHUNK_SIZE;
         if (sendableSize === 0) {
           console.log("[BackgroundUpload] Dados insuficientes para atingir 256KB. Aguardando novo chunk...");
           this.isProcessing = false;
@@ -31865,9 +31874,14 @@ var BackgroundUploadService = class _BackgroundUploadService {
       } else {
         totalSizeForHeader = virtualStart;
       }
-      const blobToSend = fullBlob.slice(0, sendableSize);
+      const payload = sendableSize === combined.byteLength ? combined : combined.subarray(0, sendableSize);
       try {
-        await this.uploadData(blobToSend, mimeType, finalChunkIndex, totalSizeForHeader);
+        await this.uploadData(
+          payload.byteLength > 0 ? payload : null,
+          mimeType,
+          finalChunkIndex,
+          totalSizeForHeader
+        );
         for (const meta of chunksWithMeta) {
           if (meta.chunk.uploaded === 0 && meta.end < this.currentOffset) {
             await this.chunkStorage.markAsUploaded(meta.chunk.id);
@@ -31878,7 +31892,10 @@ var BackgroundUploadService = class _BackgroundUploadService {
         }
         if (this.config.cleanAfterUpload) {
           const chunksToClear = chunksWithMeta.filter((meta) => meta.chunk.uploaded === 1 || meta.chunk.uploaded === 0 && meta.end < this.currentOffset);
-          const sizePurged = chunksToClear.reduce((acc, meta) => acc + meta.chunk.blob.size, 0);
+          const sizePurged = chunksToClear.reduce(
+            (acc, meta) => acc + meta.chunk.arrayBuffer.byteLength,
+            0
+          );
           await this.chunkStorage.clearUploadedChunks(this.proctoringId);
           if (sizePurged > 0) {
             this.totalBytesPurged += sizePurged;
@@ -31902,7 +31919,8 @@ var BackgroundUploadService = class _BackgroundUploadService {
   /**
    * Faz o upload bruto de dados para a sessão GCS.
    */
-  async uploadData(blob, mimeType, chunkIndex, totalSize) {
+  async uploadData(body, mimeType, chunkIndex, totalSize) {
+    var _a2;
     const fileName = `EP_${this.proctoringId}_camera_0.webm`;
     if (!this.sessionUrl) {
       const initiateUrl = await this.backend.initiateUpload(this.token, `${this.proctoringId}/${fileName}`, mimeType);
@@ -31933,16 +31951,28 @@ var BackgroundUploadService = class _BackgroundUploadService {
     } else {
       console.log(`[BackgroundUpload] Usando sess\xE3o GCS existente: ${this.sessionUrl}`);
     }
+    const size = (_a2 = body == null ? void 0 : body.byteLength) != null ? _a2 : 0;
     const start = this.currentOffset;
-    const end = start + blob.size - 1;
+    const end = start + size - 1;
     const totalHeader = totalSize !== void 0 ? totalSize.toString() : "*";
-    const contentRangeHeader = blob.size === 0 && totalSize !== void 0 ? `bytes */${totalHeader}` : `bytes ${start}-${end}/${totalHeader}`;
-    console.log(`[BackgroundUpload] Enviando ${blob.size > 0 ? "dados" : "finaliza\xE7\xE3o"}: ${contentRangeHeader} (Size: ${blob.size})`);
+    const contentRangeHeader = size === 0 && totalSize !== void 0 ? `bytes */${totalHeader}` : `bytes ${start}-${end}/${totalHeader}`;
+    console.log(
+      `[BackgroundUpload] Enviando ${size > 0 ? "dados" : "finaliza\xE7\xE3o"}: ${contentRangeHeader} (Size: ${size})`
+    );
+    let uploadBody = null;
+    if (size > 0 && body) {
+      const raw = body.buffer;
+      if (raw instanceof ArrayBuffer) {
+        uploadBody = body.byteOffset === 0 && body.byteLength === raw.byteLength ? raw : raw.slice(body.byteOffset, body.byteOffset + body.byteLength);
+      } else {
+        uploadBody = new ArrayBuffer(body.byteLength);
+        new Uint8Array(uploadBody).set(body);
+      }
+    }
     const response = await fetch(this.sessionUrl, {
       method: "PUT",
       headers: { "Content-Range": contentRangeHeader },
-      body: blob.size > 0 ? blob : null
-      // Usa null para garantir corpo vazio se necessário
+      body: uploadBody
     });
     console.log(`[BackgroundUpload] Resposta GCS (uploadData): ${response.status}`);
     if (response.status !== 200 && response.status !== 201 && response.status !== 308) {
@@ -31955,13 +31985,13 @@ var BackgroundUploadService = class _BackgroundUploadService {
       const lastByte = parseInt(rangeHeader.split("-")[1], 10);
       this.currentOffset = lastByte + 1;
     } else {
-      this.currentOffset += blob.size;
+      this.currentOffset += size;
     }
     this.saveSessionState();
     trackers.registerUploadFile(
       this.proctoringId,
       `GCS Stream Upload
-	Size: ${blob.size}
+	Size: ${size}
 	Range: ${start}-${end}
 	Last Index: ${chunkIndex}`,
       "CameraChunk"
@@ -32504,10 +32534,11 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     const savePromise = (async () => {
       var _a2;
       try {
+        const arrayBuffer = await blob.arrayBuffer();
         await this.chunkStorage.saveChunk({
           proctoringId: this.proctoringId,
           chunkIndex: this.chunkIndex,
-          blob,
+          arrayBuffer,
           timestamp: Date.now(),
           uploaded: 0,
           mimeType: ((_a2 = this.recorderOptions) == null ? void 0 : _a2.mimeType) || "video/webm"
@@ -34449,8 +34480,8 @@ var CapturePhoto = class {
   }
 };
 
-// src/extension/extensionEasyProctor.ts
-var ExtensionEasyProctor = class {
+// src/extension/extension.ts
+var Extension = class {
   constructor() {
     this.hasExtension = false;
     this.tryes = 0;
@@ -34495,89 +34526,6 @@ var ExtensionEasyProctor = class {
   }
 };
 
-// src/extension/extensionEasyCatcher.ts
-var ExtensionEasyCatcher = class {
-  constructor(options) {
-    this.hasExtension = false;
-    this.tryes = 0;
-    this.responseStart = false;
-    this.options = options || {};
-  }
-  /**
-   * Verifica se a extensão está instalada e ativa.
-   * Retorna o número da versão se encontrada, ou lança erro após timeout.
-   */
-  checkExtensionInstalled(timeoutMs = 2e3) {
-    return new Promise((resolve, reject) => {
-      let handled = false;
-      const handler = (event) => {
-        if (event.source === window && event.data.sender === "easyproctor-extension" && event.data.message_name === "version") {
-          handled = true;
-          window.removeEventListener("message", handler);
-          resolve(event.data.message);
-        }
-      };
-      window.addEventListener("message", handler);
-      window.postMessage({
-        type: "easycatcher",
-        func: "verifyExtensionEasycatcher"
-      }, "*");
-      setTimeout(() => {
-        if (!handled) {
-          window.removeEventListener("message", handler);
-          reject(new Error("Extens\xE3o n\xE3o detectada ou n\xE3o respondeu."));
-        }
-      }, timeoutMs);
-    });
-  }
-  /**
-   * Solicita o JSON da sessão atual capturado pela extensão.
-   */
-  getSessionData(timeoutMs = 5e3) {
-    return new Promise((resolve, reject) => {
-      let handled = false;
-      const handler = (event) => {
-        if (event.source === window && event.data.sender === "easyproctor-extension" && event.data.message_name === "data_response") {
-          handled = true;
-          window.removeEventListener("message", handler);
-          resolve(event.data.payload);
-        }
-      };
-      window.addEventListener("message", handler);
-      window.postMessage({
-        type: "easycatcher",
-        func: "getDataExtensionEasycatcher"
-      }, "*");
-      setTimeout(() => {
-        if (!handled) {
-          window.removeEventListener("message", handler);
-          reject(new Error("Timeout ao aguardar dados da extens\xE3o."));
-        }
-      }, timeoutMs);
-    });
-  }
-  start() {
-    return new Promise((resolve, reject) => {
-      let handled = false;
-      const handler = (event) => {
-        if (event.source === window && event.data.sender === "easyproctor-extension" && event.data.message_name === "started_confirmed") {
-          handled = true;
-          window.removeEventListener("message", handler);
-          resolve(true);
-        }
-      };
-      window.addEventListener("message", handler);
-      window.postMessage({ type: "easycatcher", func: "startExtensionEasycatcher" }, "*");
-      setTimeout(() => {
-        if (!handled) {
-          window.removeEventListener("message", handler);
-          reject(new Error("Timeout: Extens\xE3o n\xE3o confirmou o in\xEDcio."));
-        }
-      }, 3e3);
-    });
-  }
-};
-
 // src/modules/onChangeDevices.ts
 var onChangeDevices = class {
   constructor(repositoryDevices, proctoringId2, sessionOptions, allRecorders) {
@@ -38904,10 +38852,7 @@ var Proctoring = class {
       if (this.context.token === void 0) {
         throw TOKEN_MISSING;
       }
-      if (options.useChallenge) {
-        this.extensionEasycatcher = new ExtensionEasyCatcher();
-      }
-      this.extension = new ExtensionEasyProctor();
+      this.extension = new Extension();
       this.extension.addEventListener();
       const baseURL = this.backend.selectBaseUrl(this.context.type);
       const devices = await enumarateDevices();
@@ -39291,61 +39236,6 @@ Error: ` + error
       _screenStream: (_a2 = this.allRecorders.screenRecorder) == null ? void 0 : _a2.screenStream
     };
   }
-  async startChallenge(templateId) {
-    var _a2;
-    if (!this.sessionOptions.useChallenge) {
-      throw new Error("useChallenge is set as false on start method");
-    }
-    await this.extensionEasycatcher.checkExtensionInstalled().catch((err) => {
-      throw new Error("EasyCatcher Extension is not installed");
-    });
-    this.extensionEasycatcher.start();
-    const start = Date.now() - ((_a2 = this.allRecorders.cameraRecorder.getStartTime()) == null ? void 0 : _a2.getTime()) || 0;
-    await this.backend.startChallenge({
-      proctoringId: this.proctoringId,
-      templateId,
-      start
-    }).then((resp) => {
-      console.log(resp);
-      this.challengeId = resp.id;
-    }).catch((reason) => {
-      trackers.registerError(
-        this.proctoringId,
-        "N\xE3o foi poss\xEDvel iniciar desafio!"
-      );
-      throw reason;
-    });
-    this.isChallengeRunning = true;
-  }
-  async stopChallenge() {
-    var _a2;
-    if (!this.isChallengeRunning) {
-      throw new Error("Challenge not started");
-    }
-    try {
-      const sessionData = await this.extensionEasycatcher.getSessionData();
-      const end = Date.now() - ((_a2 = this.allRecorders.cameraRecorder.getStartTime()) == null ? void 0 : _a2.getTime()) || 0;
-      await this.backend.stopChallenge(
-        this.challengeId,
-        {
-          end,
-          data: sessionData
-        }
-      ).catch((reason) => {
-        trackers.registerError(
-          this.proctoringId,
-          "N\xE3o foi poss\xEDvel finalizar o desafio no backend!"
-        );
-        return void 0;
-      });
-      this.isChallengeRunning = false;
-    } catch (error) {
-      trackers.registerError(
-        this.proctoringId,
-        "Erro ao recuperar dados da extens\xE3o: " + error.message
-      );
-    }
-  }
 };
 
 // src/proctoring/SignTerm.ts
@@ -39574,8 +39464,6 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
     return originalStart(parameters2, videoOptions);
   };
   const finish = proctoring.finish.bind(proctoring);
-  const startChallenge = proctoring.startChallenge.bind(proctoring);
-  const stopChallenge = proctoring.stopChallenge.bind(proctoring);
   const pause = proctoring.pause.bind(proctoring);
   const resume = proctoring.resume.bind(proctoring);
   const onFocus = proctoring.setOnFocusCallback.bind(proctoring);
@@ -39600,8 +39488,6 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
     login,
     start,
     finish,
-    startChallenge,
-    stopChallenge,
     onFocus,
     onLostFocus,
     onChangeDevices: onChangeDevices2,

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

@@ -2,7 +2,7 @@ export interface VideoChunk {
     id?: number;
     proctoringId: string;
     chunkIndex: number;
-    blob: Blob;
+    arrayBuffer: ArrayBuffer;
     timestamp: number;
     uploaded: number;
     mimeType: string;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "easyproctor-hml",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "description": "Modulo web de gravação do EasyProctor",
   "main": "./index.js",
   "module": "./esm/index.js",
-  "unpkg": "./unpkg/easyproctor-hml.min.js",
+  "unpkg": "./unpkg/easyproctor.min.js",
   "types": "./index.d.ts",
   "keywords": [
     "proctoring"

package/proctoring/proctoring.d.ts

@@ -41,7 +41,6 @@ export declare class Proctoring {
     private readonly repository;
     private readonly repositoryDevices;
     private extension;
-    private extensionEasycatcher;
     private deviceData;
     private paramsConfig;
     private proctoringId;
@@ -101,8 +100,4 @@ 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,8 +5,6 @@ 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>;