@neofaceid/web-sdk 1.13.2 → 1.15.0

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

@@ -1652,6 +1652,110 @@ const loginWithBiometric = async (image, applicationToken) => {
     throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK_ERROR);
   }
 };
+const loginWithBiometricSSE = async (image, applicationToken) => {
+  var _a;
+  ensureSecureContext();
+  const compressedImage = await compressImage(image);
+  const arrayBuffer = await compressedImage.arrayBuffer();
+  const base64Image = btoa(
+    new Uint8Array(arrayBuffer).reduce((data, byte) => data + String.fromCharCode(byte), "")
+  );
+  const controller = createTimeoutController();
+  let response;
+  try {
+    response = await fetch(`${getApiBaseUrl()}/api/v1/auth/recognition/face/external/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-App-Token": applicationToken
+      },
+      body: JSON.stringify({ image: base64Image, purpose: "LOGIN" }),
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new NeoFaceError("Request timed out", ErrorType.NETWORK);
+      }
+      if (error instanceof NeoFaceError) throw error;
+      throw new NeoFaceError(error.message, ErrorType.NETWORK);
+    }
+    throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK_ERROR);
+  }
+  if (!response.ok) {
+    if (response.status === 401 || response.status === 403) {
+      throw new NeoFaceError("Invalid application token", ErrorType.INVALID_TOKEN);
+    }
+    throw new NeoFaceError(`API Error ${response.status}`, ErrorType.API_ERROR);
+  }
+  const initData = await response.json();
+  if (!initData.success || !((_a = initData.data) == null ? void 0 : _a.task_id)) {
+    throw new NeoFaceError(initData.message || "Failed to start login", ErrorType.LOGIN_FAILED);
+  }
+  const taskId = initData.data.task_id;
+  return new Promise((resolve, reject) => {
+    const sseUrl = `${getApiBaseUrl()}/api/v1/auth/recognition/face/external/login/events/${taskId}/`;
+    const eventSource = new EventSource(sseUrl);
+    const timeoutId = setTimeout(() => {
+      eventSource.close();
+      reject(new NeoFaceError("Login timeout", ErrorType.NETWORK));
+    }, 31e4);
+    const cleanup = () => {
+      clearTimeout(timeoutId);
+      eventSource.close();
+    };
+    eventSource.addEventListener("success", (event) => {
+      var _a2, _b, _c, _d, _e, _f;
+      cleanup();
+      try {
+        const data = JSON.parse(event.data);
+        resolve({
+          success: true,
+          accessToken: data.token || data.access_token || "",
+          alias: ((_a2 = data.user) == null ? void 0 : _a2.alias) || data.alias || "",
+          user: {
+            id: ((_b = data.user) == null ? void 0 : _b.id) || "",
+            email: ((_c = data.user) == null ? void 0 : _c.email) || "",
+            role: ((_d = data.user) == null ? void 0 : _d.role) || "",
+            validated: ((_e = data.user) == null ? void 0 : _e.validated) ?? false,
+            active: ((_f = data.user) == null ? void 0 : _f.active) ?? false
+          },
+          person: data.person ? { name: data.person.name || "", birth_date: data.person.birth_date || "" } : void 0,
+          confidence_score: data.confidence_score,
+          recognition_id: data.recognition_id ?? data.history_id
+        });
+      } catch {
+        reject(new NeoFaceError("Erro ao processar resposta de login", ErrorType.API_ERROR));
+      }
+    });
+    eventSource.addEventListener("failed", (event) => {
+      cleanup();
+      try {
+        const data = JSON.parse(event.data);
+        reject(new NeoFaceError(data.message || "Login failed", ErrorType.LOGIN_FAILED));
+      } catch {
+        reject(new NeoFaceError("Login failed", ErrorType.LOGIN_FAILED));
+      }
+    });
+    eventSource.addEventListener("error", (event) => {
+      cleanup();
+      try {
+        const data = JSON.parse(event.data || "{}");
+        reject(new NeoFaceError(data.message || "Processing error", ErrorType.API_ERROR));
+      } catch {
+        reject(new NeoFaceError("Processing error", ErrorType.API_ERROR));
+      }
+    });
+    eventSource.addEventListener("timeout", () => {
+      cleanup();
+      reject(new NeoFaceError("Login timeout", ErrorType.NETWORK));
+    });
+    eventSource.onerror = () => {
+      cleanup();
+      reject(new NeoFaceError("SSE connection error", ErrorType.NETWORK));
+    };
+  });
+};
 const recognizeBiometric = async (image, applicationToken, livenessCheck = true, confidenceThreshold = 0.8) => {
   ensureSecureContext();
   const controller = createTimeoutController();
@@ -1841,11 +1945,13 @@ const registerPersonWithoutFace = async (personData, applicationToken, options)
       password_confirm: personData.password
     };
     if (documentFrontBase64) {
-      body.document_images = [{
-        front: documentFrontBase64,
-        back: documentBackBase64 || void 0,
-        type: (options == null ? void 0 : options.documentType) || "RG"
-      }];
+      body.document_images = [
+        {
+          front: documentFrontBase64,
+          back: documentBackBase64 || void 0,
+          type: (options == null ? void 0 : options.documentType) || "RG"
+        }
+      ];
     }
     const response = await fetch(`${getApiBaseUrl()}/api/v1/signup/donor/`, {
       method: "POST",
@@ -1935,11 +2041,13 @@ const registerPersonWithBiometric = async (personData, facePhotos, applicationTo
       face_photos: facePhotosBase64
     };
     if (documentFrontBase64) {
-      body.document_images = [{
-        front: documentFrontBase64,
-        back: documentBackBase64 || void 0,
-        type: (options == null ? void 0 : options.documentType) || "RG"
-      }];
+      body.document_images = [
+        {
+          front: documentFrontBase64,
+          back: documentBackBase64 || void 0,
+          type: (options == null ? void 0 : options.documentType) || "RG"
+        }
+      ];
     }
     const response = await fetch(`${getApiBaseUrl()}/api/v1/signup/donor/`, {
       method: "POST",
@@ -2322,7 +2430,10 @@ const recordFaceVideo = async (options = {}) => {
       const selectedMimeType = getSupportedMimeType();
       let recorder;
       try {
-        recorder = selectedMimeType ? new MediaRecorder(cameraStream, { mimeType: selectedMimeType, videoBitsPerSecond: 1e6 }) : new MediaRecorder(cameraStream, { videoBitsPerSecond: 1e6 });
+        recorder = selectedMimeType ? new MediaRecorder(cameraStream, {
+          mimeType: selectedMimeType,
+          videoBitsPerSecond: 1e6
+        }) : new MediaRecorder(cameraStream, { videoBitsPerSecond: 1e6 });
       } catch {
         recorder = new MediaRecorder(cameraStream);
       }
@@ -2495,6 +2606,68 @@ const videoToBase64 = async (videoBlob) => {
     reader.readAsDataURL(videoBlob);
   });
 };
+const blobToBase64 = (blob) => new Promise((resolve, reject) => {
+  const reader = new FileReader();
+  reader.onload = () => {
+    const result = reader.result;
+    resolve(result.includes(",") ? result.split(",")[1] : result);
+  };
+  reader.onerror = () => reject(new NeoFaceError("Failed to convert image to base64", ErrorType.CAPTURE_ERROR));
+  reader.readAsDataURL(blob);
+});
+const registerDocumentByImage = async (personId, jwtToken, images) => {
+  var _a, _b;
+  ensureSecureContext();
+  if (!personId) {
+    throw new NeoFaceError("personId is required", ErrorType.VALIDATION_ERROR);
+  }
+  if (!jwtToken) {
+    throw new NeoFaceError("jwtToken is required", ErrorType.VALIDATION_ERROR);
+  }
+  if (!images || images.length === 0) {
+    throw new NeoFaceError("At least one document image is required", ErrorType.VALIDATION_ERROR);
+  }
+  const base64Images = await Promise.all(
+    images.map(async (img) => {
+      const compressed = await compressDocumentImage(img);
+      return blobToBase64(compressed);
+    })
+  );
+  const controller = createTimeoutController();
+  try {
+    const response = await fetch(`${getApiBaseUrl()}/api/v1/donors/${personId}/documents/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${jwtToken}`
+      },
+      body: JSON.stringify({ document_images: base64Images }),
+      signal: controller.signal
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      throw new NeoFaceError(
+        (data == null ? void 0 : data.message) || `API Error ${response.status}`,
+        ErrorType.NETWORK_ERROR
+      );
+    }
+    return {
+      success: true,
+      taskId: ((_a = data.data) == null ? void 0 : _a.task_id) ?? "",
+      status: ((_b = data.data) == null ? void 0 : _b.status) ?? "processing",
+      message: data.message ?? "Documents submitted for processing"
+    };
+  } catch (error) {
+    if (error instanceof NeoFaceError) throw error;
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new NeoFaceError("Request timeout", ErrorType.NETWORK_ERROR);
+      }
+      throw new NeoFaceError(error.message, ErrorType.NETWORK_ERROR);
+    }
+    throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK_ERROR);
+  }
+};
 const modalReducer$1 = (state, action) => {
   switch (action.type) {
     case "PERMISSION_GRANTED":
@@ -5065,6 +5238,7 @@ class EmailPasswordModal {
         <div class="neoface-email-modal-content">
           <h2>${this.options.title || "Login com Email e Senha"}</h2>
           <p>${this.options.subtitle || "Informe seus dados para login."}</p>
+          <div id="login-error" class="neoface-email-error" style="display:none"></div>
           <form id="email-password-form">
             <input type="email" id="email" placeholder="Email" required />
             <input type="password" id="password" placeholder="Senha" required />
@@ -5266,6 +5440,18 @@ class EmailPasswordModal {
         letter-spacing: 0.3px;
       }
 
+      .neoface-email-error {
+        background: rgba(239, 68, 68, 0.15);
+        border: 1px solid rgba(239, 68, 68, 0.4);
+        border-radius: 10px;
+        color: #fca5a5;
+        font-size: 14px;
+        padding: 12px 16px;
+        margin-bottom: 16px;
+        text-align: center;
+        animation: fadeIn 0.2s ease-out;
+      }
+
       @media (max-width: 640px) {
         .neoface-email-modal-content {
           padding: 24px;
@@ -5283,20 +5469,40 @@ class EmailPasswordModal {
     event.preventDefault();
     const emailInput = this.modalElement.querySelector("#email");
     const passwordInput = this.modalElement.querySelector("#password");
+    const submitBtn = this.modalElement.querySelector(
+      ".neoface-email-submit-btn"
+    );
+    const errorDiv = this.modalElement.querySelector("#login-error");
+    const showError = (msg) => {
+      errorDiv.textContent = msg;
+      errorDiv.style.display = "block";
+    };
+    errorDiv.style.display = "none";
+    errorDiv.textContent = "";
     const email = emailInput.value.trim();
     const password = passwordInput.value.trim();
     if (!email || !password) {
-      this.options.onError(
-        new NeoFaceError("Email e senha são obrigatórios", ErrorType.VALIDATION_ERROR)
-      );
+      showError("Preencha o email e a senha para continuar.");
       return;
     }
+    submitBtn.disabled = true;
+    submitBtn.textContent = "Entrando...";
     try {
       const result = await loginWithEmail(email, password, this.options.applicationToken);
       this.options.onSuccess(result);
       this.close();
     } catch (error) {
-      this.options.onError(error);
+      submitBtn.disabled = false;
+      submitBtn.textContent = "Entrar";
+      const isCredentialError = error instanceof NeoFaceError && (error.type === ErrorType.INVALID_TOKEN || error.type === ErrorType.API_ERROR && error.message.includes("400"));
+      if (isCredentialError) {
+        showError("Email ou senha incorretos. Verifique seus dados e tente novamente.");
+        passwordInput.value = "";
+        passwordInput.focus();
+      } else {
+        showError("Ocorreu um erro inesperado. Tente novamente mais tarde.");
+        this.options.onError(error);
+      }
     }
   }
 }
@@ -5438,7 +5644,12 @@ async function captureFaceSilently() {
           }
         }).catch((err) => {
           cleanup();
-          reject(new NeoFaceError("Erro ao reproduzir câmera: " + err.message, ErrorType.CAMERA_ERROR));
+          reject(
+            new NeoFaceError(
+              "Erro ao reproduzir câmera: " + err.message,
+              ErrorType.CAMERA_ERROR
+            )
+          );
         });
       } else {
         video.onloadedmetadata = () => setTimeout(tryCapture, CAMERA_READY_DELAY);
@@ -5580,7 +5791,10 @@ async function attemptLogin(applicationToken, overlay, fastMode = false, isRetry
       if (video.parentElement) {
         video.parentElement.removeChild(video);
       }
-      throw new NeoFaceError("Rosto não detectado. Posicione seu rosto na frente da câmera.", ErrorType.VALIDATION_ERROR);
+      throw new NeoFaceError(
+        "Rosto não detectado. Posicione seu rosto na frente da câmera.",
+        ErrorType.VALIDATION_ERROR
+      );
     }
     overlay.updateStatus("capturing");
     const canvas = document.createElement("canvas");
@@ -5618,7 +5832,7 @@ async function attemptLogin(applicationToken, overlay, fastMode = false, isRetry
       );
     });
     overlay.updateStatus("verifying");
-    const result = await loginWithBiometric(imageBlob, applicationToken);
+    const result = await loginWithBiometricSSE(imageBlob, applicationToken);
     if (!result.success) {
       throw new NeoFaceError("Login falhou", ErrorType.LOGIN_FAILED);
     }
@@ -5640,7 +5854,14 @@ async function attemptLogin(applicationToken, overlay, fastMode = false, isRetry
   }
 }
 async function executeBiometricLoginFlow(options) {
-  const { applicationToken, onSuccess, onError, onFallbackRequest, onCancel, fastMode = false } = options;
+  const {
+    applicationToken,
+    onSuccess,
+    onError,
+    onFallbackRequest,
+    onCancel,
+    fastMode = false
+  } = options;
   const overlay = new BiometricStatusOverlay();
   const fallbackPrompt = new FallbackPrompt();
   let attempts = 0;
@@ -6034,8 +6255,8 @@ const biometricDetection = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.
   initializeBiometricDetection,
   isAdvancedDetectionAvailable
 }, Symbol.toStringTag, { value: "Module" }));
-const VERSION = "1.13.2";
-const RELEASE_DATE = "2026-02-21";
+const VERSION = "1.15.0";
+const RELEASE_DATE = "2026-03-04";
 class OnboardingCaptureModal {
   constructor(options) {
     __publicField(this, "overlay", null);
@@ -6494,6 +6715,47 @@ class NeoFaceID {
    * }
    * ```
    */
+  /**
+   * Registers document images for an already-registered donor person.
+   *
+   * Opens the document capture UI (front + optional back), then submits
+   * the images to the backend for extraction via DocExt.
+   * The backend processes this asynchronously — use the returned `taskId`
+   * to poll status if needed.
+   *
+   * @param personId UUID of the donor's person record
+   * @param jwtToken JWT Bearer token of the authenticated donor
+   * @param options Optional capture configuration
+   * @returns Promise with task_id and processing status
+   * @throws NeoFaceError if capture is cancelled, validation fails, or API call fails
+   *
+   * @example
+   * ```typescript
+   * const sdk = new NeoFaceID({ appToken: 'your-token' });
+   *
+   * const result = await sdk.registerDocumentByImage(personId, userJwtToken);
+   * console.log('Task ID:', result.taskId); // poll for completion
+   * ```
+   */
+  async registerDocumentByImage(personId, jwtToken, options = {}) {
+    const { DocumentCaptureModal: DocumentCaptureModal2 } = await Promise.resolve().then(() => DocumentCaptureModal$1);
+    const modal = new DocumentCaptureModal2({
+      useBackCamera: options.useBackCamera ?? true,
+      preSelectedDocument: options.preSelectedDocument
+    });
+    const captureResult = await modal.open();
+    if (!captureResult.success || !captureResult.frontImage) {
+      throw new NeoFaceError(
+        captureResult.error === "cancelled" ? "Document capture was cancelled by the user" : `Document capture failed: ${captureResult.error ?? "unknown error"}`,
+        ErrorType.CAPTURE_ERROR
+      );
+    }
+    const images = [captureResult.frontImage];
+    if (captureResult.backImage) {
+      images.push(captureResult.backImage);
+    }
+    return registerDocumentByImage(personId, jwtToken, images);
+  }
   async proofOfLife(options = {}) {
     const {
       videoDurationMs = 3e3,
@@ -7672,6 +7934,11 @@ const startDocumentCapture = async (options) => {
   const modal = new DocumentCaptureModal(options);
   return modal.open();
 };
+const DocumentCaptureModal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DocumentCaptureModal,
+  startDocumentCapture
+}, Symbol.toStringTag, { value: "Module" }));
 function start(applicationToken, callbacks) {
   const container = document.createElement("div");
   container.id = "neoface-modal-container";