santoid-sdk 8.0.0 → 9.1.0

package/client/liveness/methods/uploadIdentificationDocument/Service.d.ts

@@ -1,25 +1,22 @@
 import { ApiTypificationService, type ITypificationResult } from '../../../../api/ApiTypificationService';
 import { ApiFaceMatchService, type IFaceMatchResult } from '../../../../api/ApiFaceMatchService';
-import { type ILivenessResults, type IBaseSDKOptions, type TCallbackFunction, type ISDKOptions } from '../../../../utils/types';
+import { type IBaseSDKOptions, type TCallbackFunction } from '../../../../utils/types';
 import { SDKError } from '../../../../utils/error';
-import { type livenessDetection } from '../livenessDetection';
-export declare class UploadIdentificationDocumentService<TFrameType, TMediaType> {
-    options: IServiceOptions<TFrameType, TMediaType>;
-    internalOptions: IInternalServiceOptions<TFrameType, TMediaType>;
+export declare class UploadIdentificationDocumentService<TFrameType> {
+    options: IServiceOptions<TFrameType>;
     typificationService: ApiTypificationService<TFrameType>;
     faceMatchService: ApiFaceMatchService<TFrameType>;
     results: IUploadIdentificationDocumentResults<TFrameType>;
-    constructor(options: IServiceOptions<TFrameType, TMediaType>, internalOptions: IInternalServiceOptions<TFrameType, TMediaType>);
+    constructor(options: IServiceOptions<TFrameType>);
     getResults(): IUploadIdentificationDocumentResults<TFrameType>;
     updateResults(updatedResults: Partial<IUploadIdentificationDocumentResults<TFrameType>>): Promise<void>;
     updateUploadedDocument(file: TFrameType): void;
     waitForResults(requestId: string): Promise<ITypificationResult>;
     waitForResultsFaceMatch(requestId: string): Promise<IFaceMatchResult>;
     startDocumentUpload(file: TFrameType): Promise<void>;
-    startLivenessDetection(startLivenessDetectionOptions?: ICustomLivenessOptions<TFrameType, TMediaType>): TLivenessDetectionReturn<TMediaType> | undefined;
     startFaceMatch(firstImage: TFrameType, secondImage: TFrameType): Promise<void>;
-    tryStartFaceMatch(): Promise<void>;
-    startAll(file: TFrameType, startLivenessDetectionOptions?: ICustomLivenessOptions<TFrameType, TMediaType>): void;
+    startFaceComparison(selfie: TFrameType): Promise<void>;
+    startAll(file: TFrameType, selfie?: TFrameType): Promise<void>;
 }
 type TResultStatuses = 'success' | 'error' | null;
 export interface IUploadIdentificationDocumentResults<TFrameType> {
@@ -30,12 +27,6 @@ export interface IUploadIdentificationDocumentResults<TFrameType> {
         loading: boolean;
         error: SDKError | null;
     };
-    liveness: {
-        status: TResultStatuses;
-        results: ILivenessResults<TFrameType | null | undefined> | null;
-        loading: boolean;
-        error: SDKError | null;
-    };
     faceMatch: {
         status: TResultStatuses;
         results: IFaceMatchResult | null;
@@ -43,28 +34,16 @@ export interface IUploadIdentificationDocumentResults<TFrameType> {
         error: SDKError | null;
     };
 }
-type ICustomLivenessOptions<TFrameType, TMediaType> = Omit<ISDKOptions<TFrameType, TMediaType>, 'track' | 'token'> & {
-    track?: string;
-    token?: string;
-};
-export interface IServiceOptions<TFrameType, TMediaType> extends IBaseSDKOptions {
-    livenessDetectionOptions?: ICustomLivenessOptions<TFrameType, TMediaType>;
+export interface IServiceOptions<TFrameType> extends IBaseSDKOptions {
     onUpdate?: (results?: IUploadIdentificationDocumentResults<TFrameType>) => void | Promise<void>;
-    onSuccess?: <TFrameType, ResultsType = ILivenessResults<TFrameType>>(results?: ResultsType) => void | Promise<void>;
+    onSuccess?: <TFrameType, ResultsType = IUploadIdentificationDocumentResults<TFrameType>>(results?: ResultsType) => void | Promise<void>;
     onError?: (error?: SDKError) => void | Promise<void>;
     onEnd?: TCallbackFunction;
     onValidationRequested?: (requestInformation: IRequestInformation) => void | Promise<void>;
     onClearInterval?: (interval: ReturnType<typeof setInterval>) => void | Promise<void>;
 }
-type TLivenessDetectionReturn<TMediaType> = Omit<ReturnType<typeof livenessDetection>, 'getVideoStream'> & {
-    getVideoStream?: () => TMediaType;
-};
-type TLivenessDetectionFn<TFrameType, TMediaType> = (options: ISDKOptions<TFrameType, TMediaType>) => TLivenessDetectionReturn<TMediaType>;
 interface IRequestInformation {
     track: string;
     requestId: string;
 }
-export interface IInternalServiceOptions<TFrameType, TMediaType> {
-    livenessDetection: TLivenessDetectionFn<TFrameType, TMediaType>;
-}
 export {};

package/client/liveness/methods/uploadIdentificationDocument/Service.js

@@ -7,15 +7,13 @@ const error_1 = require("../../../../utils/error");
 const uuid_1 = require("uuid");
 const index_1 = require("../../utils/index");
 class UploadIdentificationDocumentService {
-    constructor(options, internalOptions) {
+    constructor(options) {
         this.results = {
             uploadedDocument: null,
             typification: { status: null, results: null, loading: false, error: null },
-            liveness: { status: null, results: null, loading: false, error: null },
             faceMatch: { status: null, results: null, loading: false, error: null },
         };
         this.options = options;
-        this.internalOptions = internalOptions;
         this.typificationService = new ApiTypificationService_1.ApiTypificationService(options, { FormDataClass: FormData, tryDecodeJwt: index_1.tryDecodeJwt });
         this.faceMatchService = new ApiFaceMatchService_1.ApiFaceMatchService(options, { FormDataClass: FormData, tryDecodeJwt: index_1.tryDecodeJwt });
     }
@@ -24,14 +22,15 @@ class UploadIdentificationDocumentService {
     }
     async updateResults(updatedResults) {
         var _a, _b, _c, _d, _e, _f;
-        this.results = Object.assign(Object.assign({}, this.results), updatedResults);
-        await ((_b = (_a = this.options).onUpdate) === null || _b === void 0 ? void 0 : _b.call(_a, this.results));
-        // Prevent Face Match loop
-        if (!updatedResults.faceMatch) {
-            this.tryStartFaceMatch();
-        }
-        if (Object.entries(this.results).every(([key, value]) => key === 'uploadedDocument' || !!value.results)) {
-            await ((_d = (_c = this.options).onSuccess) === null || _d === void 0 ? void 0 : _d.call(_c, this.results));
+        const results = Object.assign(Object.assign({}, this.results), updatedResults);
+        this.results = results;
+        await ((_b = (_a = this.options).onUpdate) === null || _b === void 0 ? void 0 : _b.call(_a, results));
+        // Decide sobre o estado desta atualizacao, nao o de this.results depois do
+        // await: com upload e face match em paralelo, as duas atualizacoes finais
+        // leriam o mesmo estado e o onSuccess sairia duas vezes.
+        const { typification, faceMatch } = results;
+        if (typification.results && !typification.loading && !faceMatch.loading) {
+            await ((_d = (_c = this.options).onSuccess) === null || _d === void 0 ? void 0 : _d.call(_c, results));
             await ((_f = (_e = this.options).onEnd) === null || _f === void 0 ? void 0 : _f.call(_e));
         }
     }
@@ -121,47 +120,6 @@ class UploadIdentificationDocumentService {
             this.updateResults({ typification: { status: 'error', results: null, loading: false, error: adaptedError } });
         }
     }
-    startLivenessDetection(startLivenessDetectionOptions) {
-        var _a, _b;
-        const adaptedLivenessDetection = Object.assign(Object.assign({}, this.options.livenessDetectionOptions), startLivenessDetectionOptions);
-        this.updateResults({ liveness: { results: null, status: null, loading: true, error: null } });
-        try {
-            return this.internalOptions.livenessDetection(Object.assign(Object.assign({ domain: this.options.domain, customId: this.options.customId, customWebSocketUrl: this.options.customWebSocketUrl, token: this.options.token, track: this.options.track }, adaptedLivenessDetection), { onSuccess: async (livenessResults) => {
-                    var _a;
-                    await ((_a = adaptedLivenessDetection === null || adaptedLivenessDetection === void 0 ? void 0 : adaptedLivenessDetection.onSuccess) === null || _a === void 0 ? void 0 : _a.call(adaptedLivenessDetection, livenessResults));
-                    this.updateResults({
-                        liveness: {
-                            status: 'success',
-                            results: (livenessResults),
-                            loading: false,
-                            error: null,
-                        },
-                    });
-                }, onError: async (livenessErrorDetails) => {
-                    var _a, _b, _c;
-                    await ((_a = adaptedLivenessDetection === null || adaptedLivenessDetection === void 0 ? void 0 : adaptedLivenessDetection.onError) === null || _a === void 0 ? void 0 : _a.call(adaptedLivenessDetection, livenessErrorDetails));
-                    await ((_c = (_b = this.options).onError) === null || _c === void 0 ? void 0 : _c.call(_b, livenessErrorDetails));
-                    this.updateResults({
-                        liveness: {
-                            status: 'error',
-                            results: null,
-                            loading: (livenessErrorDetails === null || livenessErrorDetails === void 0 ? void 0 : livenessErrorDetails.code) === 'wrong-position',
-                            error: livenessErrorDetails !== null && livenessErrorDetails !== void 0 ? livenessErrorDetails : null,
-                        },
-                    });
-                } }));
-        }
-        catch (err) {
-            const adaptedError = new error_1.SDKError({
-                message: 'Error during liveness detection',
-                code: error_1.EUploadIdentificationDocumentErrorCodes.LIVENESS_DETECTION_ERROR,
-                fatal: false,
-                details: err,
-            });
-            (_b = (_a = this.options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, adaptedError);
-            this.updateResults({ liveness: { status: 'error', results: null, loading: false, error: adaptedError } });
-        }
-    }
     async startFaceMatch(firstImage, secondImage) {
         var _a, _b;
         try {
@@ -181,26 +139,27 @@ class UploadIdentificationDocumentService {
             this.updateResults({ faceMatch: { results: null, status: 'error', loading: false, error: adaptedError } });
         }
     }
-    async tryStartFaceMatch() {
-        var _a, _b, _c;
-        if (this.results.uploadedDocument &&
-            ((_a = this.results.liveness.results) === null || _a === void 0 ? void 0 : _a.successFrames.front) &&
-            !this.results.faceMatch.loading &&
-            !this.results.liveness.loading &&
-            !this.results.typification.loading) {
-            await this.startFaceMatch(this.results.uploadedDocument, this.results.liveness.results.successFrames.front);
-        }
-        else {
-            await ((_c = (_b = this.options).onError) === null || _c === void 0 ? void 0 : _c.call(_b, new error_1.SDKError({
+    // A selfie vem de quem chama - por exemplo, a foto de referencia da prova de
+    // vida (livenessSession). O documento e' o enviado em startDocumentUpload.
+    async startFaceComparison(selfie) {
+        var _a, _b;
+        if (!this.results.uploadedDocument || !selfie) {
+            await ((_b = (_a = this.options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, new error_1.SDKError({
                 message: 'Unavailable faces',
                 code: error_1.EUploadIdentificationDocumentErrorCodes.FACE_MATCH_UNAVAILABLE_FACES_ERROR,
                 fatal: false,
             })));
+            return;
         }
+        await this.startFaceMatch(this.results.uploadedDocument, selfie);
     }
-    startAll(file, startLivenessDetectionOptions) {
-        this.startDocumentUpload(file);
-        this.startLivenessDetection(startLivenessDetectionOptions);
+    // Em paralelo: o onSuccess so dispara quando nada mais esta carregando, entao
+    // em sequencia ele sairia uma vez sem o face match e outra com ele.
+    async startAll(file, selfie) {
+        await Promise.all([
+            this.startDocumentUpload(file),
+            selfie ? this.startFaceComparison(selfie) : undefined,
+        ]);
     }
 }
 exports.UploadIdentificationDocumentService = UploadIdentificationDocumentService;

package/client/liveness/methods/uploadIdentificationDocument/index.d.ts

@@ -1,22 +1,8 @@
 import { type IServiceOptions } from './Service';
-import { type TFrameType, type TMediaType } from '../livenessDetection';
-export declare function uploadIdentificationDocument(options: IServiceOptions<TFrameType, TMediaType>): {
+export type TFrameType = File | Blob;
+export declare function uploadIdentificationDocument(options: IServiceOptions<TFrameType>): {
     startDocumentUpload: (file: TFrameType) => Promise<void>;
-    startLivenessDetection: (startLivenessDetectionOptions?: (Omit<import("../../../../utils/types").ISDKOptions<TFrameType, TMediaType>, "token" | "track"> & {
-        track?: string | undefined;
-        token?: string | undefined;
-    }) | undefined) => (Omit<{
-        getVideoStream: () => TMediaType;
-        stopLivenessDetection: () => Promise<void>;
-        resumeGettingFrames: () => void;
-        pauseGettingFrames: () => void;
-    }, "getVideoStream"> & {
-        getVideoStream?: (() => TMediaType) | undefined;
-    }) | undefined;
-    startFaceComparison: () => Promise<void>;
-    startAll: (file: TFrameType, startLivenessDetectionOptions?: (Omit<import("../../../../utils/types").ISDKOptions<TFrameType, TMediaType>, "token" | "track"> & {
-        track?: string | undefined;
-        token?: string | undefined;
-    }) | undefined) => void;
+    startFaceComparison: (selfie: TFrameType) => Promise<void>;
+    startAll: (file: TFrameType, selfie?: TFrameType | undefined) => Promise<void>;
     getResults: () => import("./Service").IUploadIdentificationDocumentResults<TFrameType>;
 };

package/client/liveness/methods/uploadIdentificationDocument/index.js

@@ -2,21 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uploadIdentificationDocument = void 0;
 const Service_1 = require("./Service");
-const livenessDetection_1 = require("../livenessDetection");
 function uploadIdentificationDocument(options) {
-    const uploadIdentificationDocumentService = new Service_1.UploadIdentificationDocumentService(options, { livenessDetection: livenessDetection_1.livenessDetection });
+    const uploadIdentificationDocumentService = new Service_1.UploadIdentificationDocumentService(options);
     return {
         startDocumentUpload: async (...rest) => {
             await uploadIdentificationDocumentService.startDocumentUpload(...rest);
         },
-        startLivenessDetection: (...rest) => {
-            return uploadIdentificationDocumentService.startLivenessDetection(...rest);
-        },
         startFaceComparison: async (...rest) => {
-            await uploadIdentificationDocumentService.tryStartFaceMatch(...rest);
+            await uploadIdentificationDocumentService.startFaceComparison(...rest);
         },
-        startAll: (...rest) => {
-            uploadIdentificationDocumentService.startAll(...rest);
+        startAll: async (...rest) => {
+            await uploadIdentificationDocumentService.startAll(...rest);
         },
         getResults: (...rest) => {
             return uploadIdentificationDocumentService.getResults(...rest);

package/client/liveness-capture/index.d.ts

@@ -0,0 +1,35 @@
+import { type TLivenessCaptureColorMode, type TLivenessCaptureLanguage } from './types';
+import { type TLivenessSessionOptions } from '../liveness/methods/livenessSession';
+import { isLivenessApproved } from '../liveness/methods/livenessSession/isLivenessApproved';
+import { type ILivenessSessionResult } from '../../api/ApiLivenessSessionService';
+import { SDKError } from '../../utils/error';
+export { isLivenessApproved };
+export type { TLivenessCaptureColorMode, TLivenessCaptureLanguage };
+export interface ILivenessCaptureResult extends ILivenessSessionResult {
+    approved: boolean;
+    threshold: number;
+}
+export type TMountLivenessOptions = Omit<TLivenessSessionOptions, 'onResults' | 'onError'> & {
+    language?: TLivenessCaptureLanguage;
+    colorMode?: TLivenessCaptureColorMode;
+    /** Confianca minima para `approved`. Padrao: 80. */
+    threshold?: number;
+    /** A captura terminou e o resultado esta sendo consultado. */
+    onCaptureComplete?: () => void | Promise<void>;
+    onResult?: (result: ILivenessCaptureResult) => void | Promise<void>;
+    onError?: (error: SDKError) => void | Promise<void>;
+    onCancel?: () => void | Promise<void>;
+};
+/**
+ * Monta a captura da prova de vida dentro de `element`.
+ *
+ * Cria a sessao, abre a camera, busca o resultado e entrega em `onResult`
+ * com `approved` ja calculado. Funciona em qualquer pagina - com ou sem
+ * framework -, porque a captura roda isolada dentro do elemento.
+ *
+ * O elemento precisa de altura: a captura ocupa o espaco que ele oferece.
+ */
+export declare function mountLiveness(element: HTMLElement, options: TMountLivenessOptions): {
+    getSessionId: () => string | null;
+    unmount: () => void;
+};