@neofaceid/web-sdk 1.44.0 → 2.0.0

package/README.md

@@ -20,7 +20,7 @@ Veja o [`CHANGELOG.md`](CHANGELOG.md) para o histórico de versões.
   - [Onboarding completo (`startOnboarding`)](#onboarding-completo-startonboarding)
   - [Captura de documento (`startDocumentCapture`)](#captura-de-documento-startdocumentcapture)
   - [Autorização por biometria (`authorize` / `authorizeOperation`)](#autorização-por-biometria-authorize--authorizeoperation)
-  - [Classe `NeoFaceID` (`proofOfLife` e afins)](#classe-neofaceid-proofoflife-e-afins)
+  - [Prova de vida, captura de frames e operações avulsas](#prova-de-vida-captura-de-frames-e-operações-avulsas)
 - [Tratamento de erros](#tratamento-de-erros)
 - [Componentes React exportados](#componentes-react-exportados)
 - [Sessão de captura e desafio de liveness (baixo nível)](#sessão-de-captura-e-desafio-de-liveness-baixo-nível)
@@ -289,44 +289,47 @@ const result = await authorizeOperation('seu-token-de-aplicacao', '12345678900',
 });
 ```
 
-### Classe `NeoFaceID` (`proofOfLife` e afins)
+### Prova de vida, captura de frames e operações avulsas
 
-`NeoFaceID` reúne operações que não têm (ainda) uma função `start*`
-dedicada: prova de vida com gravação de vídeo, captura de múltiplos frames,
-login com assinatura para integrações externas, registro de aplicação e
-registro de documento pós-cadastro.
+Operações que não abrem um fluxo `start*` completo. Até a 1.x viviam na
+classe `NeoFaceID`; desde a 2.0.0 são funções, como o resto do SDK — ver a
+tabela de migração no [CHANGELOG](CHANGELOG.md#200---2026-09-19--neo-244-neo-245).
 
 ```ts
-import { NeoFaceID } from '@neofaceid/web-sdk';
-
-const sdk = new NeoFaceID({ appToken: 'seu-token-de-aplicacao' });
+import {
+  proofOfLife,
+  captureFaceFrames,
+  recognizeByPurpose,
+  registerDocumentByImage,
+} from '@neofaceid/web-sdk';
 
-// Prova de vida: grava vídeo curto, envia para o backend, faz polling do resultado
-const proof = await sdk.proofOfLife({
+// Prova de vida: grava vídeo curto, envia ao core e acompanha até o resultado.
+// `applicationToken` pode ser omitido se já foi passado a init().
+const proof = await proofOfLife({
+  applicationToken: 'seu-token-de-aplicacao',
   videoDurationMs: 3000,
   onRecordingProgress: progress => console.log(`Gravando: ${progress}%`),
   onTaskStatusChange: (status, progress) => console.log(status, progress),
 });
+// Reprovar na prova é desfecho, não exceção: confira `success` e `isLive`.
 if (proof.success && proof.isLive) {
   console.log('Liveness score:', proof.livenessScore);
   console.log('Dados da pessoa:', proof.personalData);
 }
 
-// Login com assinatura (integrações externas — ex.: sistemas que já geram HMAC)
-const sdkExterno = new NeoFaceID({
-  appToken: 'seu-token-de-aplicacao',
-  signature: signatureFromBackend, // HMAC-SHA256 hex, mínimo 64 chars
-  sessionData: { email: 'user@exemplo.com', cpf: '12345678900', sessionId: 'session-uuid' },
-});
-const frames = await sdkExterno.captureFaceFrames({ numFrames: 5, livenessCheck: true });
-const login = await sdkExterno.loginRecognition({
-  biometricData: frames,
-  typeOfIdentification: 'FACE',
-  purpose: 'LOGIN',
-});
+// Login com assinatura (integrações externas que já geram HMAC)
+const [frame] = await captureFaceFrames({ numFrames: 1, livenessCheck: false });
+const login = await recognizeByPurpose(
+  frame,
+  'seu-token-de-aplicacao',
+  'LOGIN',
+  0.8, // limiar de confiança
+  signatureFromBackend, // HMAC-SHA256 hex, mínimo 64 caracteres
+  { email: 'user@exemplo.com', cpf: '12345678900', sessionId: 'session-uuid' }
+);
 
 // Registro de documento para pessoa já cadastrada
-const docResult = await sdk.registerDocumentByImage(personId, userJwtToken);
+const docResult = await registerDocumentByImage(personId, userJwtToken);
 console.log('Task ID:', docResult.taskId);
 ```
 

package/dist/biometricDetection-8utmtR25.js

@@ -0,0 +1,154 @@
+async function detectBiometricType(imageData) {
+  try {
+    const img = await loadImageFromBase64(imageData);
+    const faceResult = await detectFace(img);
+    if (faceResult.confidence > 0.7) {
+      return {
+        type: "face",
+        confidence: faceResult.confidence,
+        details: faceResult.details
+      };
+    }
+    const handResult = await detectHand(img);
+    if (handResult.confidence > 0.6) {
+      return {
+        type: "hand",
+        confidence: handResult.confidence,
+        details: handResult.details
+      };
+    }
+    return {
+      type: "unknown",
+      confidence: Math.max(faceResult.confidence, handResult.confidence)
+    };
+  } catch (error) {
+    console.warn("Erro na detecção biométrica:", error);
+    return {
+      type: "face",
+      confidence: 0.5
+    };
+  }
+}
+async function detectFace(img) {
+  try {
+    if (typeof window !== "undefined" && window.faceapi) {
+      const { faceapi } = window;
+      await loadFaceApiModels();
+      const tinyOptions = new faceapi.TinyFaceDetectorOptions({
+        inputSize: 320,
+        scoreThreshold: 0.5
+      });
+      const detections = await faceapi.detectAllFaces(img, tinyOptions).withFaceLandmarks();
+      if (detections && detections.length > 0) {
+        const bestDetection = detections.reduce(
+          (best, current) => current.detection.score > best.detection.score ? current : best
+        );
+        return {
+          confidence: bestDetection.detection.score,
+          details: {
+            faces: detections.length,
+            landmarks: bestDetection.landmarks,
+            box: bestDetection.detection.box
+          }
+        };
+      }
+    }
+    return { confidence: 0 };
+  } catch (error) {
+    console.warn("Erro na detecção facial:", error);
+    return { confidence: 0 };
+  }
+}
+async function detectHand(img) {
+  try {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return { confidence: 0 };
+    }
+    canvas.width = img.width;
+    canvas.height = img.height;
+    ctx.drawImage(img, 0, 0);
+    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    const handFeatures = analyzeHandFeatures(imageData);
+    return {
+      confidence: handFeatures.confidence,
+      details: handFeatures
+    };
+  } catch (error) {
+    console.warn("Erro na detecção de mão:", error);
+    return { confidence: 0 };
+  }
+}
+function analyzeHandFeatures(imageData) {
+  const { data, width, height } = imageData;
+  let skinPixels = 0;
+  let totalPixels = 0;
+  for (let i = 0; i < data.length; i += 4) {
+    const r = data[i];
+    const g = data[i + 1];
+    const b = data[i + 2];
+    if (isSkinColor(r, g, b)) {
+      skinPixels++;
+    }
+    totalPixels++;
+  }
+  const skinRatio = skinPixels / totalPixels;
+  const aspectRatio = width / height;
+  const isHandAspectRatio = aspectRatio > 0.6 && aspectRatio < 1.8;
+  let confidence = 0;
+  if (skinRatio > 0.15 && skinRatio < 0.7) {
+    confidence += 0.4 * (skinRatio / 0.7);
+  }
+  if (isHandAspectRatio) {
+    confidence += 0.3;
+  }
+  const imageSize = width * height;
+  if (imageSize > 1e4 && imageSize < 5e5) {
+    confidence += 0.3;
+  }
+  return {
+    confidence: Math.min(confidence, 0.8),
+    // Máximo 80% para detecção básica
+    skinRatio,
+    aspectRatio,
+    imageSize,
+    skinPixels,
+    totalPixels
+  };
+}
+function isSkinColor(r, g, b) {
+  const y = 0.299 * r + 0.587 * g + 0.114 * b;
+  const cb = -0.169 * r - 0.331 * g + 0.5 * b + 128;
+  const cr = 0.5 * r - 0.419 * g - 0.081 * b + 128;
+  return y > 80 && y < 255 && cb > 85 && cb < 135 && cr > 135 && cr < 180;
+}
+function loadImageFromBase64(base64Data) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = () => reject(new Error("Erro ao carregar imagem"));
+    const dataUrl = base64Data.startsWith("data:") ? base64Data : `data:image/jpeg;base64,${base64Data}`;
+    img.src = dataUrl;
+  });
+}
+async function loadFaceApiModels() {
+  if (typeof window === "undefined" || !window.faceapi) {
+    return;
+  }
+  const { faceapi } = window;
+  if (faceapi.nets.tinyFaceDetector.isLoaded) {
+    return;
+  }
+  try {
+    await Promise.all([
+      faceapi.nets.tinyFaceDetector.loadFromUri("/models"),
+      faceapi.nets.faceLandmark68Net.loadFromUri("/models")
+    ]);
+  } catch (error) {
+    console.warn("Não foi possível carregar modelos do face-api.js:", error);
+  }
+}
+export {
+  detectBiometricType
+};