easyproctor-hml 2.7.9 → 2.7.11

package/index.js

@@ -31414,16 +31414,6 @@ var _ChunkStorageService = class _ChunkStorageService {
   constructor() {
     this.db = null;
   }
-  /**
-   * WebKit pode falhar em IDB.add/put com "Error preparing Blob/File data..." se o
-   * ArrayBuffer ainda estiver associado ao Blob (ex.: blob.arrayBuffer()) ou no
-   * round-trip get→put do mesmo registro. Esta cópia remove qualquer vínculo.
-   */
-  static detachedArrayBufferCopy(src) {
-    const next = new Uint8Array(src.byteLength);
-    next.set(new Uint8Array(src));
-    return next.buffer;
-  }
   /**
    * Abre a conexão com o IndexedDB, criando o banco e o object store se necessário.
    */
@@ -31463,18 +31453,10 @@ var _ChunkStorageService = class _ChunkStorageService {
    */
   async saveChunk(chunk) {
     const db = await this.connect();
-    const record = {
-      proctoringId: chunk.proctoringId,
-      chunkIndex: chunk.chunkIndex,
-      arrayBuffer: _ChunkStorageService.detachedArrayBufferCopy(chunk.arrayBuffer),
-      timestamp: chunk.timestamp,
-      uploaded: chunk.uploaded,
-      mimeType: chunk.mimeType
-    };
     return new Promise((resolve, reject) => {
       const transaction = db.transaction(_ChunkStorageService.STORE_NAME, "readwrite");
       const store = transaction.objectStore(_ChunkStorageService.STORE_NAME);
-      const request = store.add(record);
+      const request = store.add(chunk);
       request.onsuccess = () => {
         resolve(request.result);
       };
@@ -31531,35 +31513,36 @@ var _ChunkStorageService = class _ChunkStorageService {
     });
   }
   /**
-   * Remove vários chunks numa única transação (delete por chave — sem put com buffer).
+   * Marca um chunk como enviado (uploaded = 1).
    */
-  async deleteChunkIds(chunkIds) {
-    if (chunkIds.length === 0) return;
+  async markAsUploaded(chunkId) {
     const db = await this.connect();
     return new Promise((resolve, reject) => {
       const transaction = db.transaction(_ChunkStorageService.STORE_NAME, "readwrite");
       const store = transaction.objectStore(_ChunkStorageService.STORE_NAME);
-      transaction.oncomplete = () => resolve();
-      transaction.onerror = () => {
-        var _a2, _b;
-        return reject(
-          new Error(
-            `Erro ao remover chunks em lote: ${(_b = (_a2 = transaction.error) == null ? void 0 : _a2.message) != null ? _b : "unknown"}`
-          )
-        );
+      const getRequest = store.get(chunkId);
+      getRequest.onsuccess = () => {
+        const chunk = getRequest.result;
+        if (!chunk) {
+          resolve();
+          return;
+        }
+        chunk.uploaded = 1;
+        const putRequest = store.put(chunk);
+        putRequest.onsuccess = () => resolve();
+        putRequest.onerror = () => {
+          var _a2;
+          return reject(new Error(`Erro ao marcar chunk como enviado: ${(_a2 = putRequest.error) == null ? void 0 : _a2.message}`));
+        };
       };
-      transaction.onabort = () => {
-        var _a2, _b;
-        return reject(new Error(`Remo\xE7\xE3o em lote abortada: ${(_b = (_a2 = transaction.error) == null ? void 0 : _a2.message) != null ? _b : "unknown"}`));
+      getRequest.onerror = () => {
+        var _a2;
+        return reject(new Error(`Erro ao buscar chunk para marcar: ${(_a2 = getRequest.error) == null ? void 0 : _a2.message}`));
       };
-      for (const id of chunkIds) {
-        store.delete(id);
-      }
     });
   }
   /**
-   * Remove registros com uploaded = 1 (vestígio de versões antigas que faziam put).
-   * Usa openKeyCursor + delete por primaryKey para não materializar o valor (WebKit/iOS).
+   * Remove todos os chunks já enviados de um proctoringId para liberar espaço.
    */
   async clearUploadedChunks(proctoringId2) {
     const db = await this.connect();
@@ -31568,11 +31551,11 @@ var _ChunkStorageService = class _ChunkStorageService {
       const store = transaction.objectStore(_ChunkStorageService.STORE_NAME);
       const index = store.index("proctoringId_uploaded");
       const range = IDBKeyRange.only([proctoringId2, 1]);
-      const request = index.openKeyCursor(range);
+      const request = index.openCursor(range);
       request.onsuccess = () => {
         const cursor = request.result;
         if (cursor) {
-          store.delete(cursor.primaryKey);
+          cursor.delete();
           cursor.continue();
         } else {
           resolve();
@@ -31594,11 +31577,11 @@ var _ChunkStorageService = class _ChunkStorageService {
       const store = transaction.objectStore(_ChunkStorageService.STORE_NAME);
       const index = store.index("proctoringId");
       const range = IDBKeyRange.only(proctoringId2);
-      const request = index.openKeyCursor(range);
+      const request = index.openCursor(range);
       request.onsuccess = () => {
         const cursor = request.result;
         if (cursor) {
-          store.delete(cursor.primaryKey);
+          cursor.delete();
           cursor.continue();
         } else {
           resolve();
@@ -31665,8 +31648,8 @@ var _ChunkStorageService = class _ChunkStorageService {
   }
 };
 _ChunkStorageService.DB_NAME = "EasyProctorChunksDb";
-/** v2: índices numéricos; v3: ArrayBuffer no payload; v4: cópia explícita de bytes (WebKit/iOS) */
-_ChunkStorageService.DB_VERSION = 4;
+/** Incrementado para v2 para recriar índices com tipos numéricos em vez de boolean */
+_ChunkStorageService.DB_VERSION = 2;
 _ChunkStorageService.STORE_NAME = "chunks";
 var ChunkStorageService = _ChunkStorageService;
 
@@ -31826,8 +31809,7 @@ var BackgroundUploadService = class _BackgroundUploadService {
    * @param isFinal Se true, não alinha a 256KB e fecha a sessão com /TOTAL no header.
    */
   async processQueue(isFinal = false) {
-    var _a2, _b, _c2, _d, _e3, _f;
-    console.log(`[BackgroundUpload] processQueue init`);
+    var _a2, _b;
     if (this.isProcessing) return;
     this.isProcessing = true;
     try {
@@ -31840,10 +31822,8 @@ var BackgroundUploadService = class _BackgroundUploadService {
           return;
         }
       }
-      console.log(`[BackgroundUpload] processQueue syncOffset ok`);
       const allChunks = await this.chunkStorage.getAllChunks(this.proctoringId);
       const pendingChunks = allChunks.filter((c3) => c3.uploaded === 0);
-      console.log(`[BackgroundUpload] processQueue getAllChunks ok`);
       if (pendingChunks.length === 0 && !isFinal) {
         this.isProcessing = false;
         return;
@@ -31852,34 +31832,31 @@ var BackgroundUploadService = class _BackgroundUploadService {
       let virtualStart = this.totalBytesPurged;
       const chunksWithMeta = allChunks.map((c3) => {
         const start = virtualStart;
-        const end = start + c3.arrayBuffer.byteLength - 1;
-        virtualStart += c3.arrayBuffer.byteLength;
+        const end = start + c3.blob.size - 1;
+        virtualStart += c3.blob.size;
         return { chunk: c3, start, end };
       });
-      const combinedBufferParts = [];
+      let combinedBlobParts = [];
       let lastProcessedChunkId = null;
       let finalChunkIndex = 0;
-      const mimeType = (_d = (_c2 = (_a2 = pendingChunks[0]) == null ? void 0 : _a2.mimeType) != null ? _c2 : (_b = allChunks[allChunks.length - 1]) == null ? void 0 : _b.mimeType) != null ? _d : "video/webm";
-      console.log(`[BackgroundUpload]  passo 1 ok`);
+      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.arrayBuffer.slice(sliceStart);
-        combinedBufferParts.push(chunkSlice);
+        const chunkSlice = meta.chunk.blob.slice(sliceStart);
+        combinedBlobParts.push(chunkSlice);
         lastProcessedChunkId = meta.chunk.id;
         finalChunkIndex = meta.chunk.chunkIndex;
       }
-      console.log(`[BackgroundUpload]  passo 2 ok`);
-      if (combinedBufferParts.length === 0 && !isFinal) {
+      if (combinedBlobParts.length === 0 && !isFinal) {
         this.isProcessing = false;
         return;
       }
-      const fullBuffer = _BackgroundUploadService.concatArrayBuffers(combinedBufferParts);
-      console.log(`[BackgroundUpload]  passo 3 ok`);
-      let sendableSize = fullBuffer.byteLength;
+      let fullBlob = new Blob(combinedBlobParts, { type: mimeType });
+      let sendableSize = fullBlob.size;
       let totalSizeForHeader = void 0;
       if (!isFinal) {
-        sendableSize = Math.floor(fullBuffer.byteLength / this.GCS_CHUNK_SIZE) * this.GCS_CHUNK_SIZE;
+        sendableSize = Math.floor(fullBlob.size / 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;
@@ -31888,47 +31865,33 @@ var BackgroundUploadService = class _BackgroundUploadService {
       } else {
         totalSizeForHeader = virtualStart;
       }
-      console.log(`[BackgroundUpload]  passo 4 ok`);
-      const bufferToSend = sendableSize < fullBuffer.byteLength ? fullBuffer.slice(0, sendableSize) : fullBuffer;
+      const blobToSend = fullBlob.slice(0, sendableSize);
       try {
-        await this.uploadData(bufferToSend, mimeType, finalChunkIndex, totalSizeForHeader);
-        console.log(`[BackgroundUpload]  passo 5 ok`);
-        const fullySent = chunksWithMeta.filter(
-          (meta) => meta.chunk.uploaded === 0 && meta.end < this.currentOffset && meta.chunk.id != null
-        );
-        const sizePurged = fullySent.reduce(
-          (acc, meta) => acc + meta.chunk.arrayBuffer.byteLength,
-          0
-        );
-        const idsToDelete = fullySent.map((m3) => m3.chunk.id);
-        if (idsToDelete.length > 0) {
-          await this.chunkStorage.deleteChunkIds(idsToDelete);
-          for (const meta of fullySent) {
+        await this.uploadData(blobToSend, mimeType, finalChunkIndex, totalSizeForHeader);
+        for (const meta of chunksWithMeta) {
+          if (meta.chunk.uploaded === 0 && meta.end < this.currentOffset) {
+            await this.chunkStorage.markAsUploaded(meta.chunk.id);
             this.retryCount.delete(meta.chunk.id);
-            (_e3 = this.onChunkUploaded) == null ? void 0 : _e3.call(this, meta.chunk.id, meta.chunk.chunkIndex);
-            console.log(
-              `[BackgroundUpload] Chunk ${meta.chunk.chunkIndex} removido do IndexedDB ap\xF3s upload.`
-            );
+            (_a2 = this.onChunkUploaded) == null ? void 0 : _a2.call(this, meta.chunk.id, meta.chunk.chunkIndex);
+            console.log(`[BackgroundUpload] Chunk ${meta.chunk.chunkIndex} marcado como enviado.`);
           }
         }
-        console.log(`[BackgroundUpload]  passo 6 ok`);
-        await this.chunkStorage.clearUploadedChunks(this.proctoringId);
-        console.log(`[BackgroundUpload]  passo 7 ok`);
-        if (this.config.cleanAfterUpload && sizePurged > 0) {
-          this.totalBytesPurged += sizePurged;
-          this.saveSessionState();
-          console.log(
-            `[BackgroundUpload] ${sizePurged} bytes limpos do armazenamento local. Total purgado: ${this.totalBytesPurged}`
-          );
+        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);
+          await this.chunkStorage.clearUploadedChunks(this.proctoringId);
+          if (sizePurged > 0) {
+            this.totalBytesPurged += sizePurged;
+            this.saveSessionState();
+            console.log(`[BackgroundUpload] ${sizePurged} bytes limpos do armazenamento local. Total purgado: ${this.totalBytesPurged}`);
+          }
         }
-        console.log(`[BackgroundUpload]  passo 8 ok`);
         if (isFinal) {
           this.clearSessionState();
         }
-        console.log(`[BackgroundUpload]  passo 9 ok`);
       } catch (error) {
         console.error("[BackgroundUpload] Falha no upload:", error);
-        (_f = this.onUploadError) == null ? void 0 : _f.call(this, lastProcessedChunkId || 0, error);
+        (_b = this.onUploadError) == null ? void 0 : _b.call(this, lastProcessedChunkId || 0, error);
       }
     } catch (error) {
       console.error("[BackgroundUpload] Erro ao processar fila:", error);
@@ -31939,18 +31902,7 @@ var BackgroundUploadService = class _BackgroundUploadService {
   /**
    * Faz o upload bruto de dados para a sessão GCS.
    */
-  static concatArrayBuffers(parts) {
-    if (parts.length === 0) return new ArrayBuffer(0);
-    const total = parts.reduce((sum, p3) => sum + p3.byteLength, 0);
-    const merged = new Uint8Array(total);
-    let offset = 0;
-    for (const p3 of parts) {
-      merged.set(new Uint8Array(p3), offset);
-      offset += p3.byteLength;
-    }
-    return merged.buffer.byteLength === total ? merged.buffer : merged.buffer.slice(merged.byteOffset, merged.byteOffset + merged.byteLength);
-  }
-  async uploadData(data, mimeType, chunkIndex, totalSize) {
+  async uploadData(blob, mimeType, chunkIndex, totalSize) {
     const fileName = `EP_${this.proctoringId}_camera_0.webm`;
     if (!this.sessionUrl) {
       const initiateUrl = await this.backend.initiateUpload(this.token, `${this.proctoringId}/${fileName}`, mimeType);
@@ -31982,16 +31934,15 @@ var BackgroundUploadService = class _BackgroundUploadService {
       console.log(`[BackgroundUpload] Usando sess\xE3o GCS existente: ${this.sessionUrl}`);
     }
     const start = this.currentOffset;
-    const end = start + data.byteLength - 1;
+    const end = start + blob.size - 1;
     const totalHeader = totalSize !== void 0 ? totalSize.toString() : "*";
-    const contentRangeHeader = data.byteLength === 0 && totalSize !== void 0 ? `bytes */${totalHeader}` : `bytes ${start}-${end}/${totalHeader}`;
-    console.log(
-      `[BackgroundUpload] Enviando ${data.byteLength > 0 ? "dados" : "finaliza\xE7\xE3o"}: ${contentRangeHeader} (Size: ${data.byteLength})`
-    );
+    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 response = await fetch(this.sessionUrl, {
       method: "PUT",
       headers: { "Content-Range": contentRangeHeader },
-      body: data.byteLength > 0 ? data : null
+      body: blob.size > 0 ? blob : null
+      // Usa null para garantir corpo vazio se necessário
     });
     console.log(`[BackgroundUpload] Resposta GCS (uploadData): ${response.status}`);
     if (response.status !== 200 && response.status !== 201 && response.status !== 308) {
@@ -32004,13 +31955,13 @@ var BackgroundUploadService = class _BackgroundUploadService {
       const lastByte = parseInt(rangeHeader.split("-")[1], 10);
       this.currentOffset = lastByte + 1;
     } else {
-      this.currentOffset += data.byteLength;
+      this.currentOffset += blob.size;
     }
     this.saveSessionState();
     trackers.registerUploadFile(
       this.proctoringId,
       `GCS Stream Upload
-	Size: ${data.byteLength}
+	Size: ${blob.size}
 	Range: ${start}-${end}
 	Last Index: ${chunkIndex}`,
       "CameraChunk"
@@ -32145,7 +32096,7 @@ var _CameraRecorder = class _CameraRecorder {
    *  2. E (`useChunkRecording` foi explicitamente setado como true OU o dispositivo é mobile)
    */
   get isChunkEnabled() {
-    return !!this.proctoringId && this.options.proctoringType === "REALTIME" && !isSafeBrowser();
+    return false;
   }
   setProctoringId(proctoringId2) {
     this.proctoringId = proctoringId2;
@@ -32549,15 +32500,14 @@ Setting: ${JSON.stringify(settings, null, 2)}`
    * Salva o chunk no IndexedDB para persistência e recuperação.
    */
   async handleNewChunk(blob, idx) {
-    if (!this.proctoringId || !this.chunkStorage || blob.size == 0) return;
+    if (!this.proctoringId || !this.chunkStorage) return;
     const savePromise = (async () => {
       var _a2;
       try {
-        const arrayBuffer = await blob.arrayBuffer();
         await this.chunkStorage.saveChunk({
           proctoringId: this.proctoringId,
           chunkIndex: this.chunkIndex,
-          arrayBuffer,
+          blob,
           timestamp: Date.now(),
           uploaded: 0,
           mimeType: ((_a2 = this.recorderOptions) == null ? void 0 : _a2.mimeType) || "video/webm"

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

@@ -32,7 +32,6 @@ export declare class BackgroundUploadService {
     flush(): Promise<void>;
     private syncOffset;
     private processQueue;
-    private static concatArrayBuffers;
     private uploadData;
     static recoverPendingUploads(backend: BackendService, token: string): Promise<string[]>;
     private sleep;

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

@@ -2,7 +2,7 @@ export interface VideoChunk {
     id?: number;
     proctoringId: string;
     chunkIndex: number;
-    arrayBuffer: ArrayBuffer;
+    blob: Blob;
     timestamp: number;
     uploaded: number;
     mimeType: string;
@@ -12,12 +12,11 @@ export declare class ChunkStorageService {
     private static readonly DB_VERSION;
     private static readonly STORE_NAME;
     private db;
-    private static detachedArrayBufferCopy;
     connect(): Promise<IDBDatabase>;
     saveChunk(chunk: Omit<VideoChunk, "id">): Promise<number>;
     getPendingChunks(proctoringId: string): Promise<VideoChunk[]>;
     getAllChunks(proctoringId: string): Promise<VideoChunk[]>;
-    deleteChunkIds(chunkIds: number[]): Promise<void>;
+    markAsUploaded(chunkId: number): Promise<void>;
     clearUploadedChunks(proctoringId: string): Promise<void>;
     clearAllChunks(proctoringId: string): Promise<void>;
     hasAnyPendingChunks(): Promise<boolean>;

package/package.json

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