@neofaceid/web-sdk 1.39.1 → 1.40.0

package/dist/index.d.ts

@@ -483,6 +483,7 @@ export declare class DocumentCaptureModal {
     private flashController;
     private frontBlob;
     private backBlob;
+    private _previewObjectUrl;
     constructor(options?: DocumentCaptureOptions);
     open(): Promise<DocumentCaptureResult>;
     private render;
@@ -593,7 +594,9 @@ export declare enum ErrorType {
     CAPTURE_ERROR = "CaptureError",
     NOT_FOUND = "NotFoundError",
     UNKNOWN = "UnknownError",
-    CONSENT_DENIED = "ConsentDeniedError"
+    CONSENT_DENIED = "ConsentDeniedError",
+    /** NEO-224 · piscada real (EAR) não detectada dentro da janela de liveness. */
+    LIVENESS_BLINK_MISSING = "LivenessBlinkMissingError"
 }
 
 export declare function FaceCaptureModal({ accessToken, onClose, onSuccess, onCannotGesture, autoLighting, }: FaceCaptureModalProps): JSX_2.Element;
@@ -1339,7 +1342,7 @@ export declare const registerPersonWithoutFace: (personData: {
 /**
  * Data de lançamento da versão atual
  */
-export declare const RELEASE_DATE = "2026-09-08";
+export declare const RELEASE_DATE = "2026-09-09";
 
 declare interface RequestChallengeWithSessionParams {
     applicationToken: string;
@@ -1706,7 +1709,7 @@ export declare const validateToken: (applicationToken: string) => Promise<boolea
  * MINOR: Incrementado quando adicionamos funcionalidades mantendo compatibilidade
  * PATCH: Incrementado quando corrigimos bugs mantendo compatibilidade
  */
-export declare const VERSION = "1.39.1";
+export declare const VERSION = "1.40.0";
 
 /**
  * Executa `fn(sessionId)`. Se o servidor devolver 410 (sessão consumida/expirada),

package/dist/neoface-id-sdk.es.js

@@ -162,6 +162,7 @@ var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
   ErrorType2["NOT_FOUND"] = "NotFoundError";
   ErrorType2["UNKNOWN"] = "UnknownError";
   ErrorType2["CONSENT_DENIED"] = "ConsentDeniedError";
+  ErrorType2["LIVENESS_BLINK_MISSING"] = "LivenessBlinkMissingError";
   return ErrorType2;
 })(ErrorType || {});
 class NeoFaceError extends Error {
@@ -199,6 +200,8 @@ class NeoFaceError extends Error {
         return "Dados inválidos ou rosto não detectado corretamente.";
       case "ConsentDeniedError":
         return "É necessário aceitar o uso do seu rosto para continuar.";
+      case "LivenessBlinkMissingError":
+        return "Não detectamos uma piscada. Pisque os olhos naturalmente e tente novamente.";
       case "ApiError":
         if (this.message.includes("400")) return "Requisição inválida. Tente novamente.";
         if (this.message.includes("500"))
@@ -4681,6 +4684,14 @@ function getLocale() {
 function getConsent() {
   return { ...globalConfig.consent };
 }
+async function withObjectURL(blob, fn) {
+  const url = URL.createObjectURL(blob);
+  try {
+    return await fn(url);
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
 const getApiBaseUrl = () => getBaseUrl();
 const REQUEST_TIMEOUT = 1e4;
 const ensureSecureContext = () => {
@@ -4698,75 +4709,81 @@ const createTimeoutController = () => {
   controller.signal.addEventListener("abort", () => clearTimeout(timeoutId));
   return controller;
 };
-const compressImage = async (imageBlob) => new Promise((resolve, reject) => {
-  const img = new Image();
-  img.onload = () => {
-    const canvas = document.createElement("canvas");
-    canvas.width = img.width;
-    canvas.height = img.height;
-    const ctx = canvas.getContext("2d");
-    if (!ctx) {
-      reject(new Error("Failed to get canvas context"));
-      return;
-    }
-    ctx.drawImage(img, 0, 0);
-    canvas.toBlob(
-      (blob) => {
-        if (blob) {
-          resolve(blob);
-        } else {
-          reject(new Error("Failed to compress image"));
-        }
-      },
-      "image/jpeg",
-      0.7
-    );
-  };
-  img.onerror = () => {
-    reject(new Error("Failed to load image"));
-  };
-  img.src = URL.createObjectURL(imageBlob);
-});
-const compressDocumentImage = async (imageBlob) => new Promise((resolve, reject) => {
-  const img = new Image();
-  img.onload = () => {
-    const MAX_SIZE = 1280;
-    let { width } = img;
-    let { height } = img;
-    if (width > height && width > MAX_SIZE) {
-      height = height * MAX_SIZE / width;
-      width = MAX_SIZE;
-    } else if (height > MAX_SIZE) {
-      width = width * MAX_SIZE / height;
-      height = MAX_SIZE;
-    }
-    const canvas = document.createElement("canvas");
-    canvas.width = width;
-    canvas.height = height;
-    const ctx = canvas.getContext("2d");
-    if (!ctx) {
-      reject(new Error("Failed to get canvas context"));
-      return;
-    }
-    ctx.drawImage(img, 0, 0, width, height);
-    canvas.toBlob(
-      (blob) => {
-        if (blob) {
-          resolve(blob);
-        } else {
-          reject(new Error("Failed to compress document image"));
-        }
-      },
-      "image/jpeg",
-      0.75
-      // 75% quality to keep file size manageable
-    );
-  };
-  img.onerror = () => {
-    reject(new Error("Failed to load document image"));
-  };
-  img.src = URL.createObjectURL(imageBlob);
-});
+const compressImage = async (imageBlob) => withObjectURL(
+  imageBlob,
+  (url) => new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => {
+      const canvas = document.createElement("canvas");
+      canvas.width = img.width;
+      canvas.height = img.height;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        reject(new Error("Failed to get canvas context"));
+        return;
+      }
+      ctx.drawImage(img, 0, 0);
+      canvas.toBlob(
+        (blob) => {
+          if (blob) {
+            resolve(blob);
+          } else {
+            reject(new Error("Failed to compress image"));
+          }
+        },
+        "image/jpeg",
+        0.7
+      );
+    };
+    img.onerror = () => {
+      reject(new Error("Failed to load image"));
+    };
+    img.src = url;
+  })
+);
+const compressDocumentImage = async (imageBlob) => withObjectURL(
+  imageBlob,
+  (url) => new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => {
+      const MAX_SIZE = 1280;
+      let { width } = img;
+      let { height } = img;
+      if (width > height && width > MAX_SIZE) {
+        height = height * MAX_SIZE / width;
+        width = MAX_SIZE;
+      } else if (height > MAX_SIZE) {
+        width = width * MAX_SIZE / height;
+        height = MAX_SIZE;
+      }
+      const canvas = document.createElement("canvas");
+      canvas.width = width;
+      canvas.height = height;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        reject(new Error("Failed to get canvas context"));
+        return;
+      }
+      ctx.drawImage(img, 0, 0, width, height);
+      canvas.toBlob(
+        (blob) => {
+          if (blob) {
+            resolve(blob);
+          } else {
+            reject(new Error("Failed to compress document image"));
+          }
+        },
+        "image/jpeg",
+        0.75
+        // 75% quality to keep file size manageable
+      );
+    };
+    img.onerror = () => {
+      reject(new Error("Failed to load document image"));
+    };
+    img.src = url;
+  })
+);
 const validateToken = async (applicationToken) => {
   ensureSecureContext();
   const controller = createTimeoutController();
@@ -6436,6 +6453,63 @@ function ScreenFlashOverlay({
     ] })
   ] });
 }
+const POLL_INTERVAL_MS = 50;
+const MIN_HORIZONTAL_DISTANCE = 1e-6;
+function distance(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function calculateEAR(eyePoints) {
+  if (eyePoints.length !== 6) {
+    throw new Error(`calculateEAR espera exatamente 6 pontos do olho, recebeu ${eyePoints.length}`);
+  }
+  const [p1, p2, p3, p4, p5, p6] = eyePoints;
+  const verticalA = distance(p2, p6);
+  const verticalB = distance(p3, p5);
+  const horizontal = distance(p1, p4);
+  if (horizontal < MIN_HORIZONTAL_DISTANCE) return 0;
+  return (verticalA + verticalB) / (2 * horizontal);
+}
+function detectBlinkInWindow(faceapi2, videoEl, windowMs = 3e3, threshold = 0.2, signal) {
+  return new Promise((resolve) => {
+    const deadline = Date.now() + windowMs;
+    let eyesWereClosed = false;
+    let isResolved = false;
+    const finish = (result) => {
+      if (isResolved) return;
+      isResolved = true;
+      resolve(result);
+    };
+    const checkFrame = () => {
+      if (isResolved) return;
+      if (signal == null ? void 0 : signal.aborted) {
+        finish(false);
+        return;
+      }
+      if (Date.now() >= deadline) {
+        finish(false);
+        return;
+      }
+      const detectionTask = faceapi2.detectSingleFace(videoEl, new faceapi2.TinyFaceDetectorOptions()).withFaceLandmarks();
+      detectionTask.then((detection) => {
+        if (detection) {
+          const leftEAR = calculateEAR(detection.landmarks.getLeftEye());
+          const rightEAR = calculateEAR(detection.landmarks.getRightEye());
+          const ear = (leftEAR + rightEAR) / 2;
+          if (ear < threshold) {
+            eyesWereClosed = true;
+          } else if (eyesWereClosed) {
+            finish(true);
+            return;
+          }
+        }
+        setTimeout(checkFrame, POLL_INTERVAL_MS);
+      }).catch(() => {
+        setTimeout(checkFrame, POLL_INTERVAL_MS);
+      });
+    };
+    checkFrame();
+  });
+}
 const modalReducer$1 = (state, action) => {
   switch (action.type) {
     case "PERMISSION_GRANTED":
@@ -6582,6 +6656,8 @@ function FaceCaptureModal({
   const canvasRef = useRef(null);
   const streamRef = useRef(null);
   const faceDetectionTimeoutRef = useRef(null);
+  const isCapturingRef = useRef(false);
+  const blinkAbortControllerRef = useRef(null);
   const [state, dispatch] = useReducer(modalReducer$1, { status: "requestingPermission" });
   const [faceDetected, setFaceDetected] = useState(false);
   const { startCamera, stopCamera } = useCamera();
@@ -6617,6 +6693,13 @@ function FaceCaptureModal({
   useEffect(() => {
     injectThemeStyles();
   }, []);
+  useEffect(
+    () => () => {
+      var _a2;
+      (_a2 = blinkAbortControllerRef.current) == null ? void 0 : _a2.abort();
+    },
+    []
+  );
   const flashEnabled = autoLighting && (state.status === "ready" || state.status === "capturing");
   const { flashOn } = useScreenFlash(videoRef, { enabled: flashEnabled });
   useEffect(() => {
@@ -6660,19 +6743,40 @@ function FaceCaptureModal({
   }, [startCamera, stopCamera]);
   const handleCapture = async () => {
     if (!canvasRef.current || !videoRef.current) return;
+    if (isCapturingRef.current) return;
+    isCapturingRef.current = true;
+    const videoEl = videoRef.current;
+    const canvasEl = canvasRef.current;
+    const abortController = new AbortController();
+    blinkAbortControllerRef.current = abortController;
     try {
       dispatch({ type: "START_CAPTURE" });
-      const context = canvasRef.current.getContext("2d");
+      const blinkDetected = await detectBlinkInWindow(
+        faceapi,
+        videoEl,
+        void 0,
+        void 0,
+        abortController.signal
+      );
+      if (abortController.signal.aborted) return;
+      if (!blinkDetected) {
+        const blinkError = new NeoFaceError(
+          "Blink not detected within window",
+          ErrorType.LIVENESS_BLINK_MISSING
+        );
+        dispatch({ type: "SET_ERROR", message: blinkError.getFriendlyMessage() });
+        return;
+      }
+      const context = canvasEl.getContext("2d");
       if (!context) {
         dispatch({ type: "SET_ERROR", message: "Failed to get canvas context" });
         return;
       }
-      canvasRef.current.width = videoRef.current.videoWidth;
-      canvasRef.current.height = videoRef.current.videoHeight;
-      context.drawImage(videoRef.current, 0, 0, canvasRef.current.width, canvasRef.current.height);
+      canvasEl.width = videoEl.videoWidth;
+      canvasEl.height = videoEl.videoHeight;
+      context.drawImage(videoEl, 0, 0, canvasEl.width, canvasEl.height);
       const blob = await new Promise((resolve, reject) => {
-        var _a2;
-        (_a2 = canvasRef.current) == null ? void 0 : _a2.toBlob(
+        canvasEl.toBlob(
           (b) => {
             if (b) resolve(b);
             else reject(new Error("Failed to convert canvas to blob"));
@@ -6697,6 +6801,8 @@ function FaceCaptureModal({
       }
     } catch (error) {
       dispatch({ type: "SET_ERROR", message: "Failed to capture image" });
+    } finally {
+      isCapturingRef.current = false;
     }
   };
   const handleRetry = () => {
@@ -7735,6 +7841,7 @@ function BiometricRegistrationModal({
       if (onPhotosCaptured) {
         dispatch({ type: "SUCCESS" });
         onPhotosCaptured(photos);
+        photos.length = 0;
         return;
       }
       if (!personData || !applicationToken) {
@@ -7754,6 +7861,7 @@ function BiometricRegistrationModal({
       dispatch({ type: "SUCCESS" });
       if (onSuccess) {
         onSuccess(adaptedResult);
+        photos.length = 0;
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Erro desconhecido";
@@ -11163,8 +11271,8 @@ const biometricDetection = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.
   initializeBiometricDetection,
   isAdvancedDetectionAvailable
 }, Symbol.toStringTag, { value: "Module" }));
-const VERSION = "1.39.1";
-const RELEASE_DATE = "2026-09-08";
+const VERSION = "1.40.0";
+const RELEASE_DATE = "2026-09-09";
 let cachedSession = null;
 function getCachedCaptureSession() {
   return cachedSession;
@@ -12130,11 +12238,13 @@ const authorizeOperation = async (applicationToken, cpf, options) => {
       sessionData
     );
     if (!recognitionResult.success) {
+      capturedPhotos.length = 0;
       throw new NeoFaceError(
         "Authorization failed: Person not recognized",
         ErrorType.RECOGNITION_FAILED
       );
     }
+    capturedPhotos.length = 0;
     return {
       success: true,
       authorizationHash: sessionData.sessionId,
@@ -13117,6 +13227,7 @@ class DocumentCaptureModal {
     __publicField(this, "flashController", null);
     __publicField(this, "frontBlob", null);
     __publicField(this, "backBlob", null);
+    __publicField(this, "_previewObjectUrl", null);
     this.options = {
       title: (options == null ? void 0 : options.title) ?? "Validação de Identidade",
       subtitle: (options == null ? void 0 : options.subtitle) ?? "Selecione o tipo de documento",
@@ -13422,47 +13533,50 @@ class DocumentCaptureModal {
     }
   }
   compressUploadedImage(file) {
-    return new Promise((resolve, reject) => {
-      const img = new Image();
-      img.onload = () => {
-        const MAX_SIZE = 1280;
-        let { width } = img;
-        let { height } = img;
-        if (width > height && width > MAX_SIZE) {
-          height = height * MAX_SIZE / width;
-          width = MAX_SIZE;
-        } else if (height > MAX_SIZE) {
-          width = width * MAX_SIZE / height;
-          height = MAX_SIZE;
-        }
-        const canvas = document.createElement("canvas");
-        canvas.width = width;
-        canvas.height = height;
-        const ctx = canvas.getContext("2d");
-        if (!ctx) {
-          reject(new Error("Failed to get canvas context"));
-          return;
-        }
-        ctx.drawImage(img, 0, 0, width, height);
-        canvas.toBlob(
-          (blob) => {
-            if (blob) {
-              console.log(
-                `[DocumentCapture] Compressed image from ${(file.size / 1024).toFixed(0)}KB to ${(blob.size / 1024).toFixed(0)}KB`
-              );
-              resolve(blob);
-            } else {
-              reject(new Error("Failed to compress image"));
-            }
-          },
-          "image/jpeg",
-          0.75
-          // 75% quality - keeps file size manageable for server limits
-        );
-      };
-      img.onerror = () => reject(new Error("Failed to load image"));
-      img.src = URL.createObjectURL(file);
-    });
+    return withObjectURL(
+      file,
+      (url) => new Promise((resolve, reject) => {
+        const img = new Image();
+        img.onload = () => {
+          const MAX_SIZE = 1280;
+          let { width } = img;
+          let { height } = img;
+          if (width > height && width > MAX_SIZE) {
+            height = height * MAX_SIZE / width;
+            width = MAX_SIZE;
+          } else if (height > MAX_SIZE) {
+            width = width * MAX_SIZE / height;
+            height = MAX_SIZE;
+          }
+          const canvas = document.createElement("canvas");
+          canvas.width = width;
+          canvas.height = height;
+          const ctx = canvas.getContext("2d");
+          if (!ctx) {
+            reject(new Error("Failed to get canvas context"));
+            return;
+          }
+          ctx.drawImage(img, 0, 0, width, height);
+          canvas.toBlob(
+            (blob) => {
+              if (blob) {
+                console.log(
+                  `[DocumentCapture] Compressed image from ${(file.size / 1024).toFixed(0)}KB to ${(blob.size / 1024).toFixed(0)}KB`
+                );
+                resolve(blob);
+              } else {
+                reject(new Error("Failed to compress image"));
+              }
+            },
+            "image/jpeg",
+            0.75
+            // 75% quality - keeps file size manageable for server limits
+          );
+        };
+        img.onerror = () => reject(new Error("Failed to load image"));
+        img.src = url;
+      })
+    );
   }
   bindPreviewEvents() {
     var _a2, _b, _c;
@@ -13475,7 +13589,14 @@ class DocumentCaptureModal {
     );
     if (previewImg) {
       const blob = this.currentStep === "preview-front" ? this.frontBlob : this.backBlob;
-      if (blob) previewImg.src = URL.createObjectURL(blob);
+      if (blob) {
+        if (this._previewObjectUrl) {
+          URL.revokeObjectURL(this._previewObjectUrl);
+          this._previewObjectUrl = null;
+        }
+        this._previewObjectUrl = URL.createObjectURL(blob);
+        previewImg.src = this._previewObjectUrl;
+      }
     }
     this.bindCloseEvent();
   }
@@ -13662,6 +13783,10 @@ class DocumentCaptureModal {
   }
   close() {
     this.stopCamera();
+    if (this._previewObjectUrl) {
+      URL.revokeObjectURL(this._previewObjectUrl);
+      this._previewObjectUrl = null;
+    }
     if (this.overlay) {
       this.overlay.remove();
       this.overlay = null;