@dynamicore/jumio-sdk 1.0.0 → 1.0.2

package/dist/index.mjs

@@ -1,86 +1,81 @@
 import axios from 'axios';
 import { useMemo, useState, useRef, useEffect, useCallback } from 'react';
 
-// src/core/errors.ts
-var JumioError = class extends Error {
-  isJumioError = true;
-  statusCode;
-  rawData;
-  code;
-  constructor(message, options) {
-    super(message);
-    this.name = "JumioError";
-    this.statusCode = options?.statusCode;
-    this.rawData = options?.rawData;
-    this.code = options?.code;
-    if (options?.cause) {
-      this.cause = options.cause;
-    }
-  }
-};
-var JumioTimeoutError = class extends JumioError {
-  constructor(message = "El servicio de verificaci\xF3n de Jumio excedi\xF3 el tiempo l\xEDmite de espera.", rawData) {
-    super(message, { code: "TIMEOUT", rawData });
-    this.name = "JumioTimeoutError";
-  }
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var JumioNetworkError = class extends JumioError {
-  constructor(message = "No fue posible comunicarse con los servidores de validaci\xF3n de identidad.", cause) {
-    super(message, { code: "NETWORK_ERROR", cause });
-    this.name = "JumioNetworkError";
-  }
-};
-var JumioValidationError = class extends JumioError {
-  constructor(message = "El documento no pudo ser validado o fue rechazado por Jumio.", rawData) {
-    super(message, { code: "VALIDATION_FAILED", rawData });
-    this.name = "JumioValidationError";
-  }
-};
-var JumioImageProcessingError = class extends JumioError {
-  constructor(message, cause) {
-    super(message, { code: "IMAGE_PROCESSING_ERROR", cause });
-    this.name = "JumioImageProcessingError";
-  }
-};
-var JumioPollingTimeoutError = class extends JumioError {
-  attempts;
-  constructor(attempts, message = "La validaci\xF3n sigue en proceso. Por favor verifica nuevamente m\xE1s tarde.", rawData) {
-    super(message, { code: "POLLING_TIMEOUT", rawData });
-    this.name = "JumioPollingTimeoutError";
-    this.attempts = attempts;
-  }
-};
-var JumioAbortError = class extends JumioError {
-  constructor(message = "La operaci\xF3n de validaci\xF3n de Jumio fue cancelada.") {
-    super(message, { code: "ABORTED" });
-    this.name = "JumioAbortError";
-  }
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
+
+// src/core/errors.ts
 function isJumioError(error) {
   return error instanceof JumioError || typeof error === "object" && error !== null && "isJumioError" in error && error.isJumioError === true;
 }
+var JumioError, JumioTimeoutError, JumioNetworkError, JumioValidationError, JumioImageProcessingError, JumioPollingTimeoutError, JumioAbortError;
+var init_errors = __esm({
+  "src/core/errors.ts"() {
+    JumioError = class extends Error {
+      isJumioError = true;
+      statusCode;
+      rawData;
+      code;
+      constructor(message, options) {
+        super(message);
+        this.name = "JumioError";
+        this.statusCode = options?.statusCode;
+        this.rawData = options?.rawData;
+        this.code = options?.code;
+        if (options?.cause) {
+          this.cause = options.cause;
+        }
+      }
+    };
+    JumioTimeoutError = class extends JumioError {
+      constructor(message = "El servicio de verificaci\xF3n de Jumio excedi\xF3 el tiempo l\xEDmite de espera.", rawData) {
+        super(message, { code: "TIMEOUT", rawData });
+        this.name = "JumioTimeoutError";
+      }
+    };
+    JumioNetworkError = class extends JumioError {
+      constructor(message = "No fue posible comunicarse con los servidores de validaci\xF3n de identidad.", cause) {
+        super(message, { code: "NETWORK_ERROR", cause });
+        this.name = "JumioNetworkError";
+      }
+    };
+    JumioValidationError = class extends JumioError {
+      constructor(message = "El documento no pudo ser validado o fue rechazado por Jumio.", rawData) {
+        super(message, { code: "VALIDATION_FAILED", rawData });
+        this.name = "JumioValidationError";
+      }
+    };
+    JumioImageProcessingError = class extends JumioError {
+      constructor(message, cause) {
+        super(message, { code: "IMAGE_PROCESSING_ERROR", cause });
+        this.name = "JumioImageProcessingError";
+      }
+    };
+    JumioPollingTimeoutError = class extends JumioError {
+      attempts;
+      constructor(attempts, message = "La validaci\xF3n sigue en proceso. Por favor verifica nuevamente m\xE1s tarde.", rawData) {
+        super(message, { code: "POLLING_TIMEOUT", rawData });
+        this.name = "JumioPollingTimeoutError";
+        this.attempts = attempts;
+      }
+    };
+    JumioAbortError = class extends JumioError {
+      constructor(message = "La operaci\xF3n de validaci\xF3n de Jumio fue cancelada.") {
+        super(message, { code: "ABORTED" });
+        this.name = "JumioAbortError";
+      }
+    };
+  }
+});
 
 // src/core/envelope.ts
-var FINAL_JUMIO_STATUSES = [
-  "PROCESSED",
-  "APPROVED_VERIFIED",
-  "REJECTED",
-  "FAILED",
-  "ERROR",
-  "DENIED",
-  "EXPIRED",
-  "ABANDONED",
-  "DONE",
-  "COMPLETED",
-  "NOT_READABLE",
-  "FRAUD",
-  "UNSUPPORTED_ID_TYPE"
-];
-var APPROVED_JUMIO_STATUSES = [
-  "APPROVED_VERIFIED",
-  "DONE",
-  "COMPLETED"
-];
 function toLowerText(value) {
   return String(value ?? "").trim().toLowerCase();
 }
@@ -88,10 +83,13 @@ function toUpperText(value) {
   return String(value ?? "").trim().toUpperCase();
 }
 function extractEnvelopeData(responseData) {
-  if (responseData && typeof responseData === "object" && "data" in responseData) {
-    const candidate = responseData.data;
-    if (candidate !== void 0) {
-      return candidate;
+  if (responseData && typeof responseData === "object") {
+    const obj = responseData;
+    if ("data" in obj && obj.data !== void 0) {
+      return obj.data;
+    }
+    if ("values" in obj && obj.values !== void 0) {
+      return obj.values;
     }
   }
   return responseData;
@@ -162,6 +160,48 @@ function resolveVerificationValidity(data, fallbackStatus) {
   }
   return isApprovedJumioStatus(fallbackStatus);
 }
+function encodeUrlToBase64UrlSafe(url) {
+  try {
+    let base64;
+    if (typeof Buffer !== "undefined") {
+      base64 = Buffer.from(url, "utf-8").toString("base64");
+    } else if (typeof TextEncoder !== "undefined") {
+      const encoder = new TextEncoder();
+      const data = encoder.encode(url);
+      base64 = btoa(String.fromCharCode(...new Uint8Array(data)));
+    } else {
+      base64 = btoa(url);
+    }
+    return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  } catch {
+    return null;
+  }
+}
+var FINAL_JUMIO_STATUSES, APPROVED_JUMIO_STATUSES;
+var init_envelope = __esm({
+  "src/core/envelope.ts"() {
+    FINAL_JUMIO_STATUSES = [
+      "PROCESSED",
+      "APPROVED_VERIFIED",
+      "REJECTED",
+      "FAILED",
+      "ERROR",
+      "DENIED",
+      "EXPIRED",
+      "ABANDONED",
+      "DONE",
+      "COMPLETED",
+      "NOT_READABLE",
+      "FRAUD",
+      "UNSUPPORTED_ID_TYPE"
+    ];
+    APPROVED_JUMIO_STATUSES = [
+      "APPROVED_VERIFIED",
+      "DONE",
+      "COMPLETED"
+    ];
+  }
+});
 
 // src/core/retry.ts
 function delay(ms, signal) {
@@ -233,8 +273,268 @@ async function withRetry(operation, options = {}) {
   }
   throw lastError;
 }
+var init_retry = __esm({
+  "src/core/retry.ts"() {
+    init_envelope();
+    init_errors();
+  }
+});
+
+// src/core/webflow.ts
+var webflow_exports = {};
+__export(webflow_exports, {
+  buildRedirectUrl: () => buildRedirectUrl,
+  parseWebflowReturnParams: () => parseWebflowReturnParams,
+  pollWebflowStatus: () => pollWebflowStatus,
+  resolveWebflowResult: () => resolveWebflowResult,
+  startWebflowSession: () => startWebflowSession
+});
+function buildRedirectUrl(returnUrl, proxyUrl) {
+  if (!proxyUrl) {
+    return returnUrl;
+  }
+  const encoded = encodeUrlToBase64UrlSafe(returnUrl);
+  if (!encoded) {
+    throw new JumioValidationError(
+      `No fue posible codificar la URL de retorno: "${returnUrl}"`
+    );
+  }
+  const normalizedProxy = proxyUrl.endsWith("/") ? proxyUrl : `${proxyUrl}/`;
+  return `${normalizedProxy}${encoded}`;
+}
+function parseWebflowReturnParams(source) {
+  let searchString;
+  if (!source) {
+    if (typeof window !== "undefined" && window.location) {
+      searchString = window.location.search;
+    } else {
+      return { allParams: {} };
+    }
+  } else if (typeof source === "string") {
+    const questionIdx = source.indexOf("?");
+    searchString = questionIdx >= 0 ? source.slice(questionIdx) : "";
+  } else if (source instanceof URLSearchParams) {
+    searchString = `?${source.toString()}`;
+  } else {
+    const hrefSearch = source.href ? (() => {
+      try {
+        return new URL(source.href).search;
+      } catch {
+        return "";
+      }
+    })() : "";
+    searchString = source.search ?? hrefSearch;
+  }
+  const params = new URLSearchParams(searchString);
+  const allParams = {};
+  params.forEach((value, key) => {
+    allParams[key] = value;
+  });
+  const accountId = params.get("accountId") ?? void 0;
+  let workflowId = params.get("workflowExecutionId") ?? params.get("workflowId") ?? void 0;
+  const rawStatus = params.get("status") ?? void 0;
+  if (rawStatus && (!accountId || !workflowId)) {
+    const statusParts = rawStatus.split("?");
+    const nestedSearch = statusParts.length > 1 ? `?${statusParts.slice(1).join("?")}` : "";
+    if (nestedSearch && nestedSearch !== "?") {
+      const nestedParams = new URLSearchParams(nestedSearch);
+      nestedParams.forEach((value, key) => {
+        if (!allParams[key]) allParams[key] = value;
+      });
+      if (!workflowId) {
+        workflowId = nestedParams.get("workflowExecutionId") ?? nestedParams.get("workflowId") ?? workflowId;
+      }
+    }
+  }
+  return {
+    accountId: accountId || void 0,
+    workflowId: workflowId || void 0,
+    rawStatus,
+    allParams
+  };
+}
+function resolveWebflowResult(rawData, accountId, workflowId) {
+  if (!rawData || typeof rawData !== "object") return null;
+  const data = rawData;
+  if (data.valid === true) {
+    return {
+      valid: true,
+      status: String(data.workflowStatus ?? data.status ?? "APPROVED_VERIFIED"),
+      decision: data.decision,
+      extraction: data.extraction,
+      accountId,
+      workflowId,
+      data: rawData
+    };
+  }
+  if (data.valid === false) {
+    return {
+      valid: false,
+      status: String(data.workflowStatus ?? data.status ?? "REJECTED"),
+      decision: data.decision,
+      accountId,
+      workflowId,
+      data: rawData,
+      errorMessage: extractJumioMessage(rawData) || "El documento fue rechazado durante la verificacion."
+    };
+  }
+  const capData = data;
+  const decisionType = capData?.decision?.type;
+  const extractionArr = capData?.capabilities?.extraction ?? [];
+  const extraction = extractionArr[0];
+  const isExtractionEmpty = extraction !== void 0 && Object.keys(extraction).length === 0;
+  if (decisionType === "REJECTED") {
+    return {
+      valid: false,
+      status: "REJECTED",
+      decision: decisionType,
+      accountId,
+      workflowId,
+      data: rawData,
+      errorMessage: extractJumioMessage(rawData) || "El documento fue rechazado por Jumio."
+    };
+  }
+  if (extraction && !isExtractionEmpty) {
+    const isApproved = decisionType === "PASSED" || decisionType === "WARNING";
+    return {
+      valid: isApproved,
+      status: isApproved ? decisionType ?? "PASSED" : decisionType ?? "REJECTED",
+      decision: decisionType,
+      extraction,
+      accountId,
+      workflowId,
+      data: rawData,
+      ...!isApproved ? {
+        errorMessage: extractJumioMessage(rawData) || "La verificacion no fue aprobada."
+      } : {}
+    };
+  }
+  return null;
+}
+async function pollWebflowStatus(http, params, options = {}) {
+  const config = http.getConfig();
+  const maxAttempts = options.maxAttempts ?? config.maxPollingAttempts ?? 20;
+  const intervalMs = options.pollingIntervalMs ?? config.pollingIntervalMs ?? 1e4;
+  const signal = options.signal;
+  let lastRawData = {};
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (signal?.aborted) {
+      throw new JumioAbortError();
+    }
+    const responseData = await withRetry(
+      () => http.getVerificationStatus(params.accountId, params.workflowId, {
+        signal,
+        timeout: config.statusTimeout,
+        clientId: params.clientId
+      }),
+      {
+        maxRetries: config.maxRetries ?? 3,
+        initialDelayMs: config.retryDelayMs ?? 800,
+        signal
+      }
+    );
+    const firstLevel = extractEnvelopeData(responseData);
+    const statusData = extractNestedData(firstLevel) ?? {};
+    lastRawData = statusData;
+    options.onAttempt?.(attempt, maxAttempts, statusData);
+    const result = resolveWebflowResult(
+      statusData,
+      params.accountId,
+      params.workflowId
+    );
+    if (result !== null) {
+      return result;
+    }
+    if (attempt < maxAttempts) {
+      await delay(intervalMs, signal);
+    }
+  }
+  const lastMessage = extractJumioMessage(lastRawData) || "La verificacion Jumio sigue en proceso. Intenta nuevamente en unos momentos.";
+  throw new JumioPollingTimeoutError(maxAttempts, lastMessage, lastRawData);
+}
+async function startWebflowSession(http, config, input) {
+  const {
+    clientId,
+    successUrl,
+    errorUrl,
+    useRedirectProxy = false,
+    autoRedirect = false,
+    openInNewTab = false,
+    signal
+  } = input;
+  if (!clientId?.trim()) {
+    throw new JumioValidationError(
+      "Se requiere un identificador de cliente valido (clientId)."
+    );
+  }
+  if (!successUrl?.trim()) {
+    throw new JumioValidationError("Se requiere la URL de exito (successUrl).");
+  }
+  if (!errorUrl?.trim()) {
+    throw new JumioValidationError("Se requiere la URL de error (errorUrl).");
+  }
+  if (signal?.aborted) {
+    throw new JumioAbortError();
+  }
+  const proxyUrl = useRedirectProxy ? config.redirectProxyUrl ?? void 0 : void 0;
+  const finalSuccessUrl = buildRedirectUrl(successUrl, proxyUrl);
+  const finalErrorUrl = buildRedirectUrl(errorUrl, proxyUrl);
+  try {
+    const responseData = await withRetry(
+      () => http.postVerification(
+        {
+          client: clientId.trim(),
+          successUrl: finalSuccessUrl,
+          errorUrl: finalErrorUrl
+        },
+        { signal, timeout: config.requestTimeout }
+      ),
+      {
+        maxRetries: config.maxRetries ?? 3,
+        initialDelayMs: config.retryDelayMs ?? 800,
+        signal
+      }
+    );
+    const firstLevel = extractEnvelopeData(responseData);
+    const payload = extractNestedData(firstLevel) ?? {};
+    const href = payload?.href;
+    if (!href) {
+      throw new JumioError(
+        extractJumioMessage(payload) || "El backend no devolvio la URL de verificacion de Jumio (href).",
+        { rawData: payload }
+      );
+    }
+    const result = {
+      href,
+      accountId: payload?.accountId,
+      workflowId: payload?.workflowId,
+      data: payload
+    };
+    if (typeof window !== "undefined") {
+      if (openInNewTab) {
+        const win = window.open(href, "_blank");
+        if (!win || win.closed || typeof win.closed === "undefined") {
+          window.location.href = href;
+        }
+      } else if (autoRedirect) {
+        window.location.href = href;
+      }
+    }
+    return result;
+  } catch (err) {
+    throw err;
+  }
+}
+var init_webflow = __esm({
+  "src/core/webflow.ts"() {
+    init_envelope();
+    init_errors();
+    init_retry();
+  }
+});
 
 // src/core/image.ts
+init_errors();
 function stripDataUrlPrefix(dataUrl) {
   if (!dataUrl) return "";
   const commaIndex = dataUrl.indexOf(",");
@@ -390,6 +690,10 @@ async function resolveImageSourceToBase64(source, s3Signer, signal) {
   }
   throw new JumioImageProcessingError("Tipo de dato de imagen no soportado.");
 }
+
+// src/core/http.ts
+init_errors();
+init_envelope();
 var JumioHttpClient = class {
   client;
   config;
@@ -505,6 +809,7 @@ var JumioHttpClient = class {
   }
   /**
    * Ejecuta una petición GET para consultar el estado actual de una verificación de INE.
+   * Soporta un `clientId` opcional requerido por algunos endpoints de DynamiCore (p. ej. Hosted Webflow).
    */
   async getVerificationStatus(accountId, workflowId, options) {
     if (options?.signal?.aborted) {
@@ -514,12 +819,16 @@ var JumioHttpClient = class {
       const dynamicHeaders = await this.resolveHeaders();
       const endpoint = this.config.endpoint || "/marketplace/apps/jumio";
       const timeout = options?.timeout ?? this.config.statusTimeout ?? 12e4;
+      const queryParams = {
+        type: "ine",
+        accountId,
+        workflowId
+      };
+      if (options?.clientId) {
+        queryParams.clientId = options.clientId;
+      }
       const response = await this.client.get(endpoint, {
-        params: {
-          type: "ine",
-          accountId,
-          workflowId
-        },
+        params: queryParams,
         headers: dynamicHeaders,
         timeout,
         signal: options?.signal
@@ -535,6 +844,9 @@ var JumioHttpClient = class {
 };
 
 // src/core/polling.ts
+init_envelope();
+init_errors();
+init_retry();
 async function pollJumioStatus(http, accountId, workflowId, options = {}) {
   const config = http.getConfig();
   const maxAttempts = options.maxAttempts ?? config.maxPollingAttempts ?? 20;
@@ -591,6 +903,10 @@ async function pollJumioStatus(http, accountId, workflowId, options = {}) {
 }
 
 // src/core/client.ts
+init_envelope();
+init_errors();
+init_retry();
+init_webflow();
 var JumioClient = class {
   http;
   config;
@@ -730,10 +1046,110 @@ var JumioClient = class {
     onStatusResolved?.(finalResult);
     return finalResult;
   }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Hosted Webflow (Redirección)
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Construye la URL de redirección de retorno para el flujo Hosted Webflow.
+   *
+   * Si el cliente está configurado con un `redirectProxyUrl` y `useProxy` es `true`,
+   * la URL de retorno se codifica en Base64 URL-safe y se adjunta al proxy.
+   *
+   * @param returnUrl URL de la aplicación a la que Jumio redirigirá tras la verificación.
+   * @param useProxy Si es `true` y hay `redirectProxyUrl` configurado, usa el proxy.
+   * @returns URL de redirección construida.
+   */
+  buildRedirectUrl(returnUrl, useProxy = false) {
+    const proxyUrl = useProxy ? this.config.redirectProxyUrl ?? void 0 : void 0;
+    return buildRedirectUrl(returnUrl, proxyUrl);
+  }
+  /**
+   * Inicia el flujo Hosted Webflow solicitando al backend de DynamiCore la URL
+   * de verificación de Jumio (`href`).
+   *
+   * El usuario debe ser redirigido a esa URL para completar la verificación en la
+   * página oficial de Jumio. Al terminar, Jumio redirige de vuelta a la aplicación
+   * con `accountId` y `workflowExecutionId` como query params.
+   *
+   * @param input Parámetros del flujo: `clientId`, `successUrl`, `errorUrl`, opciones de proxy y redirección.
+   * @returns `StartWebflowResult` con la URL de Jumio (`href`) y datos adicionales.
+   *
+   * @example
+   * ```ts
+   * const { href } = await client.startWebflow({
+   *   clientId: "usr_123",
+   *   successUrl: "https://app.example.com/verify/success",
+   *   errorUrl: "https://app.example.com/verify/error",
+   * });
+   * window.location.href = href;
+   * ```
+   */
+  async startWebflow(input) {
+    return startWebflowSession(this.http, this.config, input);
+  }
+  /**
+   * Extrae los parámetros de seguimiento de Jumio de la URL de retorno.
+   *
+   * Jumio añade `accountId` y `workflowExecutionId` (o `workflowId`) como query
+   * params al redirigir de vuelta a la aplicación tras la verificación.
+   *
+   * @param source URL completa, `URLSearchParams`, objeto con `search`/`href`, o nada para leer `window.location`.
+   * @returns `WebflowReturnParams` con `accountId`, `workflowId`, `rawStatus` y todos los params.
+   *
+   * @example En React, en el componente de retorno:
+   * ```ts
+   * const { accountId, workflowId } = client.parseWebflowReturnParams(window.location.href);
+   * ```
+   */
+  parseWebflowReturnParams(source) {
+    return parseWebflowReturnParams(source);
+  }
+  /**
+   * Consulta una única vez el estado actual de la verificación del flujo Hosted Webflow.
+   *
+   * @param input Parámetros de consulta: `accountId`, `workflowId`, y `clientId` opcional.
+   * @returns `WebflowResult | null` — `null` si la verificación aún está pendiente.
+   */
+  async getWebflowStatus(input) {
+    const { accountId, workflowId, clientId, signal } = input;
+    const responseData = await this.http.getVerificationStatus(accountId, workflowId, {
+      signal,
+      timeout: this.config.statusTimeout,
+      clientId
+    });
+    const firstLevel = extractEnvelopeData(responseData);
+    const statusData = extractNestedData(firstLevel) ?? {};
+    const { resolveWebflowResult: resolveWebflowResult2 } = await Promise.resolve().then(() => (init_webflow(), webflow_exports));
+    return resolveWebflowResult2(statusData, accountId, workflowId);
+  }
+  /**
+   * Sondea periódicamente el estado de verificación de un flujo Hosted Webflow de Jumio.
+   *
+   * Continúa consultando hasta obtener un resultado definitivo o agotar los intentos.
+   *
+   * @param params `accountId`, `workflowId` y `clientId` opcional.
+   * @param options Opciones de sondeo (`maxAttempts`, `pollingIntervalMs`, `signal`, `onAttempt`).
+   * @returns `WebflowResult` con el resultado definitivo.
+   *
+   * @example
+   * ```ts
+   * // En el componente de retorno, tras leer los params de la URL:
+   * const result = await client.pollWebflowStatus({ accountId, workflowId, clientId });
+   * if (result.valid) {
+   *   console.log("Verificación aprobada:", result.extraction);
+   * } else {
+   *   console.warn("Rechazado:", result.errorMessage);
+   * }
+   * ```
+   */
+  async pollWebflowStatus(params, options) {
+    return pollWebflowStatus(this.http, params, options);
+  }
 };
 function createJumioClient(config) {
   return new JumioClient(config);
 }
+init_errors();
 var INITIAL_STATE = {
   isSubmitting: false,
   isPolling: false,
@@ -885,6 +1301,13 @@ function useJumioVerification(options = {}) {
       };
       const handleError = (err) => {
         if (err instanceof JumioAbortError) {
+          setState((prev) => ({
+            ...prev,
+            isSubmitting: false,
+            isPolling: false,
+            isLoading: false,
+            stage: "CANCELLED"
+          }));
           return;
         }
         setState((prev) => ({
@@ -948,7 +1371,207 @@ function useJumioVerification(options = {}) {
     client
   };
 }
+init_errors();
+var INITIAL_STATE2 = {
+  isStarting: false,
+  isChecking: false,
+  isLoading: false,
+  result: null,
+  error: null,
+  isValid: false,
+  isRejected: false
+};
+function useJumioWebflow(options = {}) {
+  const {
+    client: customClient,
+    baseUrl,
+    endpoint,
+    context,
+    authToken,
+    authTokenPrefix,
+    requestTimeout,
+    statusTimeout,
+    maxRetries,
+    retryDelayMs,
+    pollingIntervalMs,
+    maxPollingAttempts,
+    redirectProxyUrl,
+    s3Signer,
+    customHeaders,
+    axiosInstance,
+    onResult: globalOnResult,
+    onError: globalOnError
+  } = options;
+  const client = useMemo(() => {
+    if (customClient) return customClient;
+    return new JumioClient({
+      baseUrl,
+      endpoint,
+      context,
+      authToken,
+      authTokenPrefix,
+      requestTimeout,
+      statusTimeout,
+      maxRetries,
+      retryDelayMs,
+      pollingIntervalMs,
+      maxPollingAttempts,
+      redirectProxyUrl,
+      s3Signer,
+      customHeaders,
+      axiosInstance
+    });
+  }, [
+    customClient,
+    baseUrl,
+    endpoint,
+    context,
+    authToken,
+    authTokenPrefix,
+    requestTimeout,
+    statusTimeout,
+    maxRetries,
+    retryDelayMs,
+    pollingIntervalMs,
+    maxPollingAttempts,
+    redirectProxyUrl,
+    s3Signer,
+    customHeaders,
+    axiosInstance
+  ]);
+  const [state, setState] = useState(INITIAL_STATE2);
+  const abortControllerRef = useRef(null);
+  const callbacksRef = useRef({ onResult: globalOnResult, onError: globalOnError });
+  useEffect(() => {
+    callbacksRef.current = { onResult: globalOnResult, onError: globalOnError };
+  }, [globalOnResult, globalOnError]);
+  useEffect(() => {
+    return () => {
+      abortControllerRef.current?.abort();
+    };
+  }, []);
+  const cancel = useCallback(() => {
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
+    setState((prev) => ({
+      ...prev,
+      isStarting: false,
+      isChecking: false,
+      isLoading: false
+    }));
+  }, []);
+  const reset = useCallback(() => {
+    cancel();
+    setState(INITIAL_STATE2);
+  }, [cancel]);
+  const handleError = useCallback((err) => {
+    if (err instanceof JumioAbortError) {
+      setState((prev) => ({
+        ...prev,
+        isStarting: false,
+        isChecking: false,
+        isLoading: false
+      }));
+      return;
+    }
+    setState((prev) => ({
+      ...prev,
+      isStarting: false,
+      isChecking: false,
+      isLoading: false,
+      error: err,
+      isRejected: true
+    }));
+    callbacksRef.current.onError?.(err);
+  }, []);
+  const handleResult = useCallback((result) => {
+    setState((prev) => ({
+      ...prev,
+      isChecking: false,
+      isLoading: false,
+      result,
+      isValid: result.valid,
+      isRejected: !result.valid,
+      error: result.valid ? null : new Error(result.errorMessage ?? "Verificacion de identidad rechazada")
+    }));
+    callbacksRef.current.onResult?.(result);
+  }, []);
+  const startWebflow = useCallback(
+    async (input) => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      setState({
+        ...INITIAL_STATE2,
+        isStarting: true,
+        isLoading: true
+      });
+      try {
+        const result = await client.startWebflow({
+          ...input,
+          signal: input.signal ?? controller.signal
+        });
+        setState((prev) => ({
+          ...prev,
+          isStarting: false,
+          isLoading: false
+        }));
+        return result;
+      } catch (err) {
+        const normalizedError = err instanceof Error ? err : new Error(String(err));
+        handleError(normalizedError);
+        throw normalizedError;
+      }
+    },
+    [client, handleError]
+  );
+  const checkResult = useCallback(
+    async (params, pollOptions) => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      setState((prev) => ({
+        ...prev,
+        isChecking: true,
+        isLoading: true,
+        error: null
+      }));
+      try {
+        const result = await client.pollWebflowStatus(params, {
+          ...pollOptions,
+          signal: pollOptions?.signal ?? controller.signal
+        });
+        handleResult(result);
+        return result;
+      } catch (err) {
+        const normalizedError = err instanceof Error ? err : new Error(String(err));
+        handleError(normalizedError);
+        throw normalizedError;
+      }
+    },
+    [client, handleResult, handleError]
+  );
+  const parseReturnParams = useCallback(
+    (source) => {
+      return client.parseWebflowReturnParams(source);
+    },
+    [client]
+  );
+  return {
+    ...state,
+    startWebflow,
+    checkResult,
+    parseReturnParams,
+    cancel,
+    reset,
+    client
+  };
+}
 
-export { APPROVED_JUMIO_STATUSES, FINAL_JUMIO_STATUSES, JumioAbortError, JumioClient, JumioError, JumioHttpClient, JumioImageProcessingError, JumioNetworkError, JumioPollingTimeoutError, JumioTimeoutError, JumioValidationError, arrayBufferToBase64, blobToBase64, createJumioClient, delay, extractEnvelopeData, extractJumioMessage, extractNestedData, fetchUrlAsBase64, isApprovedJumioStatus, isBase64String, isFinalJumioStatus, isJumioError, isPassedJumioDecision, normalizeSignedUrl, pollJumioStatus, resolveImageSourceToBase64, resolveVerificationValidity, shouldRetryJumio, stripDataUrlPrefix, toLowerText, toUpperText, useJumioVerification, withRetry };
+export { APPROVED_JUMIO_STATUSES, FINAL_JUMIO_STATUSES, JumioAbortError, JumioClient, JumioError, JumioHttpClient, JumioImageProcessingError, JumioNetworkError, JumioPollingTimeoutError, JumioTimeoutError, JumioValidationError, arrayBufferToBase64, blobToBase64, buildRedirectUrl, createJumioClient, delay, encodeUrlToBase64UrlSafe, extractEnvelopeData, extractJumioMessage, extractNestedData, fetchUrlAsBase64, isApprovedJumioStatus, isBase64String, isFinalJumioStatus, isJumioError, isPassedJumioDecision, normalizeSignedUrl, parseWebflowReturnParams, pollJumioStatus, pollWebflowStatus, resolveImageSourceToBase64, resolveVerificationValidity, resolveWebflowResult, shouldRetryJumio, startWebflowSession, stripDataUrlPrefix, toLowerText, toUpperText, useJumioVerification, useJumioWebflow, withRetry };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map