@dynamicore/jumio-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,993 @@
+'use strict';
+
+var axios = require('axios');
+var react = require('react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+// 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 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";
+  }
+};
+function isJumioError(error) {
+  return error instanceof JumioError || typeof error === "object" && error !== null && "isJumioError" in error && error.isJumioError === true;
+}
+
+// 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();
+}
+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;
+    }
+  }
+  return responseData;
+}
+function extractNestedData(source, maxDepth = 4) {
+  let current = source;
+  let depth = 0;
+  while (depth < maxDepth && current && typeof current === "object" && "data" in current) {
+    const next = current.data;
+    if (next == null) break;
+    current = next;
+    depth += 1;
+  }
+  return current;
+}
+function extractJumioMessage(source) {
+  if (!source) return "";
+  if (typeof source === "string") return source.trim();
+  if (source instanceof Error) {
+    return source.message;
+  }
+  if (typeof source === "object") {
+    const record = source;
+    if (record.response && typeof record.response === "object") {
+      const responseObj = record.response;
+      const subMessage = extractJumioMessage(responseObj.data);
+      if (subMessage) return subMessage;
+    }
+    const directCandidates = [
+      record.message,
+      record.msg,
+      record.error,
+      record.detail,
+      record.errorMessage,
+      record.description,
+      record.reason
+    ];
+    for (const cand of directCandidates) {
+      if (typeof cand === "string" && cand.trim()) {
+        return cand.trim();
+      }
+    }
+    if (record.data) {
+      return extractJumioMessage(record.data);
+    }
+  }
+  return "";
+}
+function isFinalJumioStatus(status) {
+  const upperStatus = toUpperText(status);
+  if (!upperStatus) return false;
+  return FINAL_JUMIO_STATUSES.some((s) => s === upperStatus);
+}
+function isApprovedJumioStatus(status) {
+  const upperStatus = toUpperText(status);
+  if (!upperStatus) return false;
+  return upperStatus === "APPROVED_VERIFIED" || upperStatus === "DONE" || upperStatus === "COMPLETED";
+}
+function isPassedJumioDecision(decision) {
+  return toUpperText(decision) === "PASSED";
+}
+function resolveVerificationValidity(data, fallbackStatus) {
+  if (typeof data.valid === "boolean") {
+    return data.valid;
+  }
+  if (data.decision) {
+    return isPassedJumioDecision(data.decision);
+  }
+  return isApprovedJumioStatus(fallbackStatus);
+}
+
+// src/core/retry.ts
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      return reject(new JumioAbortError());
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abortHandler);
+      resolve();
+    }, ms);
+    const abortHandler = () => {
+      clearTimeout(timer);
+      reject(new JumioAbortError());
+    };
+    signal?.addEventListener("abort", abortHandler, { once: true });
+  });
+}
+function shouldRetryJumio(errorOrMessage) {
+  if (!errorOrMessage) return false;
+  const text = toLowerText(
+    typeof errorOrMessage === "string" ? errorOrMessage : extractJumioMessage(errorOrMessage)
+  );
+  const errorObj = errorOrMessage;
+  const status = errorObj?.status || errorObj?.response?.status;
+  const code = String(errorObj?.code || "").toUpperCase();
+  if (status === 408 || status === 502 || status === 503 || status === 504) {
+    return true;
+  }
+  if (code === "ECONNABORTED" || code === "ETIMEDOUT" || code === "ECONNRESET" || code === "EAI_AGAIN") {
+    return true;
+  }
+  return text.includes("timed out") || text.includes("timeout") || text.includes("temporarily unavailable") || text.includes("network error") || text.includes("socket hang up") || text.includes("gateway timeout") || text.includes("service unavailable") || text.includes("excedi\xF3 el tiempo de espera");
+}
+async function withRetry(operation, options = {}) {
+  const {
+    maxRetries = 3,
+    initialDelayMs = 800,
+    maxDelayMs = 1e4,
+    factor = 1.5,
+    shouldRetry = shouldRetryJumio,
+    signal,
+    onRetry
+  } = options;
+  let lastError;
+  for (let attempt = 1; attempt <= maxRetries; attempt += 1) {
+    if (signal?.aborted) {
+      throw new JumioAbortError();
+    }
+    try {
+      return await operation(attempt);
+    } catch (error) {
+      lastError = error;
+      if (signal?.aborted) {
+        throw new JumioAbortError();
+      }
+      const isLastAttempt = attempt >= maxRetries;
+      const isRetryable = shouldRetry(error);
+      if (isLastAttempt || !isRetryable) {
+        throw error;
+      }
+      const currentDelay = Math.min(
+        Math.round(initialDelayMs * Math.pow(factor, attempt - 1)),
+        maxDelayMs
+      );
+      onRetry?.(attempt, error, currentDelay);
+      await delay(currentDelay, signal);
+    }
+  }
+  throw lastError;
+}
+
+// src/core/image.ts
+function stripDataUrlPrefix(dataUrl) {
+  if (!dataUrl) return "";
+  const commaIndex = dataUrl.indexOf(",");
+  return commaIndex >= 0 ? dataUrl.slice(commaIndex + 1).trim() : dataUrl.trim();
+}
+function isBase64String(input) {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("data:")) return true;
+  if (!trimmed.startsWith("http://") && !trimmed.startsWith("https://") && !trimmed.startsWith("blob:") && !trimmed.startsWith("/")) {
+    return /^[A-Za-z0-9+/=_\-\r\n]+$/.test(trimmed);
+  }
+  return false;
+}
+function normalizeSignedUrl(input, fallback = "") {
+  if (typeof input === "string" && input.trim()) {
+    return input.trim();
+  }
+  if (input && typeof input === "object") {
+    const record = input;
+    if ("url" in record && typeof record.url === "string" && record.url.trim()) {
+      return record.url.trim();
+    }
+    if ("Location" in record && typeof record.Location === "string" && record.Location.trim()) {
+      return record.Location.trim();
+    }
+    if ("signedUrl" in record && typeof record.signedUrl === "string" && record.signedUrl.trim()) {
+      return record.signedUrl.trim();
+    }
+  }
+  return fallback;
+}
+function blobToBase64(blob) {
+  return new Promise((resolve, reject) => {
+    if (typeof FileReader === "undefined") {
+      blob.arrayBuffer().then((buffer) => {
+        resolve(arrayBufferToBase64(buffer));
+      }).catch(
+        (err) => reject(new JumioImageProcessingError("No se pudo leer el archivo binario.", err))
+      );
+      return;
+    }
+    const reader = new FileReader();
+    reader.onload = () => {
+      const dataUrl = String(reader.result ?? "");
+      resolve(stripDataUrlPrefix(dataUrl));
+    };
+    reader.onerror = () => reject(new JumioImageProcessingError("No se pudo convertir la imagen a base64.", reader.error));
+    reader.readAsDataURL(blob);
+  });
+}
+function arrayBufferToBase64(buffer) {
+  if (typeof Buffer !== "undefined") {
+    const nodeBuf = buffer instanceof Uint8Array ? Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength) : Buffer.from(buffer);
+    return nodeBuf.toString("base64");
+  }
+  let binary = "";
+  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+  const len = bytes.byteLength;
+  for (let i = 0; i < len; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+async function fetchUrlAsBase64(url, signal) {
+  if (signal?.aborted) {
+    throw new JumioAbortError();
+  }
+  const trimmed = url.trim();
+  if (trimmed.startsWith("data:")) {
+    return stripDataUrlPrefix(trimmed);
+  }
+  try {
+    const response = await fetch(trimmed, { signal });
+    if (!response.ok) {
+      throw new JumioImageProcessingError(
+        `No se pudo descargar la imagen desde la URL remota (HTTP ${response.status}).`
+      );
+    }
+    const blob = await response.blob();
+    return await blobToBase64(blob);
+  } catch (error) {
+    if (signal?.aborted || error instanceof Error && error.name === "AbortError") {
+      throw new JumioAbortError();
+    }
+    if (error instanceof JumioImageProcessingError) {
+      throw error;
+    }
+    throw new JumioImageProcessingError(
+      `Error al descargar o procesar la imagen desde la URL: ${url}`,
+      error
+    );
+  }
+}
+async function resolveImageSourceToBase64(source, s3Signer, signal) {
+  if (signal?.aborted) {
+    throw new JumioAbortError();
+  }
+  if (!source) {
+    throw new JumioImageProcessingError("No se proporcion\xF3 una imagen v\xE1lida para la verificaci\xF3n.");
+  }
+  if (typeof Blob !== "undefined" && source instanceof Blob) {
+    return blobToBase64(source);
+  }
+  if (source instanceof ArrayBuffer || source instanceof Uint8Array) {
+    return arrayBufferToBase64(source);
+  }
+  if (typeof source === "object" && source !== null) {
+    const extractedUrl = normalizeSignedUrl(source, "");
+    if (extractedUrl) {
+      return resolveImageSourceToBase64(extractedUrl, s3Signer, signal);
+    }
+  }
+  if (typeof source === "string") {
+    const text = source.trim();
+    if (!text) {
+      throw new JumioImageProcessingError("La ruta o contenido de la imagen est\xE1 vac\xEDo.");
+    }
+    if (text.startsWith("data:")) {
+      return stripDataUrlPrefix(text);
+    }
+    if (text.startsWith("http://") || text.startsWith("https://") || text.startsWith("blob:")) {
+      if (s3Signer && (text.includes(".amazonaws.com") || text.includes("/s3/"))) {
+        try {
+          const signed = await s3Signer(text, 300);
+          const signedUrl = normalizeSignedUrl(signed, text);
+          return await fetchUrlAsBase64(signedUrl, signal);
+        } catch {
+          return await fetchUrlAsBase64(text, signal);
+        }
+      }
+      return await fetchUrlAsBase64(text, signal);
+    }
+    if (s3Signer && (text.startsWith("company/") || text.startsWith("/") || text.includes("/"))) {
+      try {
+        const signed = await s3Signer(text, 300);
+        const signedUrl = normalizeSignedUrl(signed, "");
+        if (signedUrl) {
+          return await fetchUrlAsBase64(signedUrl, signal);
+        }
+      } catch (err) {
+        throw new JumioImageProcessingError(
+          `No se pudo firmar la ruta de almacenamiento S3: ${text}`,
+          err
+        );
+      }
+    }
+    if (isBase64String(text)) {
+      return stripDataUrlPrefix(text);
+    }
+    throw new JumioImageProcessingError(
+      `Formato de imagen no reconocido o ruta inv\xE1lida: ${text.slice(0, 50)}...`
+    );
+  }
+  throw new JumioImageProcessingError("Tipo de dato de imagen no soportado.");
+}
+var JumioHttpClient = class {
+  client;
+  config;
+  constructor(config = {}) {
+    this.config = {
+      baseUrl: "https://front.dynamicore.io",
+      endpoint: "/marketplace/apps/jumio",
+      requestTimeout: 18e4,
+      statusTimeout: 12e4,
+      maxRetries: 3,
+      retryDelayMs: 800,
+      pollingIntervalMs: 1e4,
+      maxPollingAttempts: 20,
+      authTokenPrefix: "",
+      ...config
+    };
+    if (config.axiosInstance) {
+      this.client = config.axiosInstance;
+    } else {
+      this.client = axios__default.default.create({
+        baseURL: this.config.baseUrl,
+        headers: {
+          "Content-Type": "application/json",
+          ...this.config.context ? { context: this.config.context } : {},
+          ...this.config.customHeaders || {}
+        }
+      });
+    }
+  }
+  /**
+   * Resuelve los headers dinámicos (token de auth y context).
+   */
+  async resolveHeaders() {
+    const headers = {
+      ...this.config.customHeaders || {}
+    };
+    if (this.config.context) {
+      headers["context"] = this.config.context;
+    }
+    if (this.config.authToken) {
+      let token;
+      if (typeof this.config.authToken === "function") {
+        token = await this.config.authToken();
+      } else {
+        token = this.config.authToken;
+      }
+      if (token) {
+        const prefix = this.config.authTokenPrefix ? `${this.config.authTokenPrefix.trim()} ` : "";
+        headers["Authorization"] = `${prefix}${token}`;
+      }
+    }
+    return headers;
+  }
+  /**
+   * Normaliza cualquier error de Axios a una excepción tipada JumioError.
+   */
+  normalizeError(error) {
+    if (error instanceof JumioError) {
+      return error;
+    }
+    if (axios__default.default.isAxiosError(error)) {
+      const axiosErr = error;
+      const status = axiosErr.response?.status;
+      const responseData = axiosErr.response?.data;
+      const serverMessage = extractJumioMessage(responseData) || extractJumioMessage(axiosErr);
+      if (axiosErr.code === "ECONNABORTED" || axiosErr.code === "ETIMEDOUT") {
+        return new JumioTimeoutError(
+          serverMessage || "La solicitud al servicio de Jumio excedi\xF3 el tiempo l\xEDmite.",
+          responseData
+        );
+      }
+      if (!axiosErr.response) {
+        return new JumioNetworkError(
+          serverMessage || "No fue posible comunicarse con el servicio de Jumio.",
+          axiosErr
+        );
+      }
+      return new JumioError(serverMessage || `Error en la solicitud HTTP (${status}).`, {
+        statusCode: status,
+        rawData: responseData,
+        code: axiosErr.code,
+        cause: axiosErr
+      });
+    }
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        return new JumioAbortError();
+      }
+      return new JumioError(error.message, { cause: error });
+    }
+    return new JumioError("Ocurri\xF3 un error inesperado al contactar a Jumio.");
+  }
+  /**
+   * Ejecuta una petición POST al endpoint de Jumio para iniciar o procesar la verificación.
+   */
+  async postVerification(payload, options) {
+    if (options?.signal?.aborted) {
+      throw new JumioAbortError();
+    }
+    try {
+      const dynamicHeaders = await this.resolveHeaders();
+      const endpoint = this.config.endpoint || "/marketplace/apps/jumio";
+      const timeout = options?.timeout ?? this.config.requestTimeout ?? 18e4;
+      const response = await this.client.post(endpoint, payload, {
+        headers: dynamicHeaders,
+        timeout,
+        signal: options?.signal
+      });
+      return response.data;
+    } catch (err) {
+      throw this.normalizeError(err);
+    }
+  }
+  /**
+   * Ejecuta una petición GET para consultar el estado actual de una verificación de INE.
+   */
+  async getVerificationStatus(accountId, workflowId, options) {
+    if (options?.signal?.aborted) {
+      throw new JumioAbortError();
+    }
+    try {
+      const dynamicHeaders = await this.resolveHeaders();
+      const endpoint = this.config.endpoint || "/marketplace/apps/jumio";
+      const timeout = options?.timeout ?? this.config.statusTimeout ?? 12e4;
+      const response = await this.client.get(endpoint, {
+        params: {
+          type: "ine",
+          accountId,
+          workflowId
+        },
+        headers: dynamicHeaders,
+        timeout,
+        signal: options?.signal
+      });
+      return response.data;
+    } catch (err) {
+      throw this.normalizeError(err);
+    }
+  }
+  getConfig() {
+    return this.config;
+  }
+};
+
+// src/core/polling.ts
+async function pollJumioStatus(http, accountId, workflowId, options = {}) {
+  const config = http.getConfig();
+  const maxAttempts = options.maxAttempts ?? config.maxPollingAttempts ?? 20;
+  const intervalMs = options.pollingIntervalMs ?? config.pollingIntervalMs ?? 1e4;
+  const signal = options.signal;
+  let lastData = {};
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    if (signal?.aborted) {
+      throw new JumioAbortError();
+    }
+    const responseData = await withRetry(
+      () => http.getVerificationStatus(accountId, workflowId, {
+        signal,
+        timeout: config.statusTimeout
+      }),
+      {
+        maxRetries: config.maxRetries ?? 3,
+        initialDelayMs: config.retryDelayMs ?? 800,
+        signal
+      }
+    );
+    const firstLevel = extractEnvelopeData(responseData);
+    const statusData = extractNestedData(firstLevel) ?? {};
+    lastData = statusData;
+    options.onAttempt?.(attempt, maxAttempts, statusData);
+    if (statusData.valid === true) {
+      return {
+        valid: true,
+        status: statusData.workflowStatus || statusData.status || "APPROVED_VERIFIED",
+        accountId,
+        workflowId,
+        data: statusData
+      };
+    }
+    const workflowStatus = statusData.workflowStatus ?? statusData.status ?? statusData.decision;
+    if (isFinalJumioStatus(workflowStatus) || statusData.decision && isPassedJumioDecision(statusData.decision)) {
+      const isValid = resolveVerificationValidity(statusData, workflowStatus);
+      const errorMessage = isValid ? void 0 : extractJumioMessage(statusData) || "El documento fue rechazado durante la validaci\xF3n.";
+      return {
+        valid: isValid,
+        status: String(workflowStatus),
+        accountId,
+        workflowId,
+        data: statusData,
+        errorMessage
+      };
+    }
+    if (attempt < maxAttempts) {
+      await delay(intervalMs, signal);
+    }
+  }
+  const lastMessage = extractJumioMessage(lastData) || "La validaci\xF3n de INE sigue en proceso. Intenta nuevamente en unos momentos.";
+  throw new JumioPollingTimeoutError(maxAttempts, lastMessage, lastData);
+}
+
+// src/core/client.ts
+var JumioClient = class {
+  http;
+  config;
+  constructor(config = {}) {
+    this.config = config;
+    this.http = new JumioHttpClient(config);
+  }
+  /**
+   * Inicia el proceso de verificación convirtiendo las imágenes y enviando el payload inicial a Jumio.
+   */
+  async startIneVerification(params) {
+    const { clientId, frontImage, backImage, signal, onProgress } = params;
+    if (!clientId || !clientId.trim()) {
+      throw new JumioValidationError("Se requiere un identificador de cliente v\xE1lido (clientId).");
+    }
+    if (signal?.aborted) {
+      throw new JumioAbortError();
+    }
+    onProgress?.("RESOLVING_IMAGES", 10);
+    const [frontBase64, backBase64] = await Promise.all([
+      resolveImageSourceToBase64(frontImage, this.config.s3Signer, signal),
+      resolveImageSourceToBase64(backImage, this.config.s3Signer, signal)
+    ]);
+    if (signal?.aborted) {
+      throw new JumioAbortError();
+    }
+    onProgress?.("SENDING_PAYLOAD", 40);
+    const payload = {
+      client: clientId.trim(),
+      front_image_b64: frontBase64,
+      back_image_b64: backBase64
+    };
+    const response = await withRetry(
+      () => this.http.postVerification(payload, {
+        signal,
+        timeout: this.config.requestTimeout
+      }),
+      {
+        maxRetries: this.config.maxRetries ?? 3,
+        initialDelayMs: this.config.retryDelayMs ?? 800,
+        signal
+      }
+    );
+    onProgress?.("PAYLOAD_SENT", 60);
+    const firstLevel = extractEnvelopeData(response);
+    const startData = extractNestedData(firstLevel) ?? {};
+    return startData;
+  }
+  /**
+   * Consulta una única vez el estado actual de la validación.
+   */
+  async getIneStatus(accountId, workflowId, signal) {
+    const response = await this.http.getVerificationStatus(
+      accountId,
+      workflowId,
+      { signal, timeout: this.config.statusTimeout }
+    );
+    const firstLevel = extractEnvelopeData(response);
+    return extractNestedData(firstLevel) ?? {};
+  }
+  /**
+   * Sondea periódicamente el estado hasta obtener un resultado definitivo.
+   */
+  async pollIneStatus(accountId, workflowId, options) {
+    return pollJumioStatus(this.http, accountId, workflowId, options);
+  }
+  /**
+   * Ejecuta el flujo completo de validación de INE.
+   *
+   * @param input Parámetros de validación y callbacks.
+   * @returns `VerifyIneResult` con el resultado inicial o definitivo según `awaitFinalStatus`.
+   */
+  async verifyIne(input) {
+    const {
+      clientId,
+      frontImage,
+      backImage,
+      awaitFinalStatus = false,
+      onStatusResolved,
+      onStatusError,
+      onProgress,
+      signal
+    } = input;
+    const startData = await this.startIneVerification({
+      clientId,
+      frontImage,
+      backImage,
+      signal,
+      onProgress
+    });
+    const startStatus = startData?.workflowStatus ?? startData?.status ?? startData?.decision;
+    const isStartFinal = isFinalJumioStatus(startStatus);
+    if (startData?.valid === true || startData?.valid === false && isStartFinal) {
+      const isValid = startData?.valid === true;
+      const immediateResult = {
+        valid: isValid,
+        status: startStatus || (isValid ? "APPROVED_VERIFIED" : "REJECTED"),
+        accountId: startData?.accountId,
+        workflowId: startData?.workflowId,
+        data: startData,
+        ...isValid ? {} : {
+          errorMessage: extractJumioMessage(startData) || "El documento fue rechazado durante la validaci\xF3n."
+        }
+      };
+      onProgress?.("COMPLETED", 100);
+      onStatusResolved?.(immediateResult);
+      return immediateResult;
+    }
+    const accountId = String(startData?.accountId ?? "").trim();
+    const workflowId = String(startData?.workflowId ?? "").trim();
+    if (!accountId || !workflowId) {
+      const errorMessage = extractJumioMessage(startData) || "No fue posible obtener los identificadores de seguimiento de la validaci\xF3n.";
+      const error = new JumioError(errorMessage, { rawData: startData });
+      onStatusError?.(error);
+      throw error;
+    }
+    if (!awaitFinalStatus) {
+      onProgress?.("POLLING_BACKGROUND", 70);
+      this.pollIneStatus(accountId, workflowId).then((finalResult2) => {
+        onProgress?.("COMPLETED", 100);
+        onStatusResolved?.(finalResult2);
+      }).catch((err) => {
+        const normalizedError = err instanceof Error ? err : new Error("No se pudo consultar el estatus de validaci\xF3n.");
+        onStatusError?.(normalizedError);
+      });
+      return {
+        valid: true,
+        status: startData.status || startData.workflowStatus || "INITIATED",
+        accountId,
+        workflowId,
+        data: startData
+      };
+    }
+    onProgress?.("POLLING_FOREGROUND", 70);
+    const finalResult = await this.pollIneStatus(accountId, workflowId, { signal });
+    onProgress?.("COMPLETED", 100);
+    onStatusResolved?.(finalResult);
+    return finalResult;
+  }
+};
+function createJumioClient(config) {
+  return new JumioClient(config);
+}
+var INITIAL_STATE = {
+  isSubmitting: false,
+  isPolling: false,
+  isLoading: false,
+  stage: "IDLE",
+  progress: 0,
+  result: null,
+  error: null,
+  isSuccess: false,
+  isError: false
+};
+function useJumioVerification(options = {}) {
+  const {
+    client: customClient,
+    baseUrl,
+    endpoint,
+    context,
+    authToken,
+    authTokenPrefix,
+    requestTimeout,
+    statusTimeout,
+    maxRetries,
+    retryDelayMs,
+    pollingIntervalMs,
+    maxPollingAttempts,
+    s3Signer,
+    customHeaders,
+    axiosInstance,
+    onStatusResolved: globalOnStatusResolved,
+    onStatusError: globalOnStatusError,
+    onProgress: globalOnProgress
+  } = options;
+  const client = react.useMemo(() => {
+    if (customClient) return customClient;
+    return new JumioClient({
+      baseUrl,
+      endpoint,
+      context,
+      authToken,
+      authTokenPrefix,
+      requestTimeout,
+      statusTimeout,
+      maxRetries,
+      retryDelayMs,
+      pollingIntervalMs,
+      maxPollingAttempts,
+      s3Signer,
+      customHeaders,
+      axiosInstance
+    });
+  }, [
+    customClient,
+    baseUrl,
+    endpoint,
+    context,
+    authToken,
+    authTokenPrefix,
+    requestTimeout,
+    statusTimeout,
+    maxRetries,
+    retryDelayMs,
+    pollingIntervalMs,
+    maxPollingAttempts,
+    s3Signer,
+    customHeaders,
+    axiosInstance
+  ]);
+  const [state, setState] = react.useState(INITIAL_STATE);
+  const abortControllerRef = react.useRef(null);
+  const callbacksRef = react.useRef({
+    onStatusResolved: globalOnStatusResolved,
+    onStatusError: globalOnStatusError,
+    onProgress: globalOnProgress
+  });
+  react.useEffect(() => {
+    callbacksRef.current = {
+      onStatusResolved: globalOnStatusResolved,
+      onStatusError: globalOnStatusError,
+      onProgress: globalOnProgress
+    };
+  }, [globalOnStatusResolved, globalOnStatusError, globalOnProgress]);
+  react.useEffect(() => {
+    return () => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+    };
+  }, []);
+  const cancel = react.useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    setState((prev) => ({
+      ...prev,
+      isSubmitting: false,
+      isPolling: false,
+      isLoading: false,
+      stage: "CANCELLED"
+    }));
+  }, []);
+  const reset = react.useCallback(() => {
+    cancel();
+    setState(INITIAL_STATE);
+  }, [cancel]);
+  const verify = react.useCallback(
+    async (input) => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      setState({
+        isSubmitting: true,
+        isPolling: false,
+        isLoading: true,
+        stage: "STARTING",
+        progress: 5,
+        result: null,
+        error: null,
+        isSuccess: false,
+        isError: false
+      });
+      const handleProgress = (stage, percent) => {
+        setState((prev) => ({
+          ...prev,
+          stage,
+          progress: percent ?? prev.progress,
+          isPolling: stage.includes("POLLING")
+        }));
+        input.onProgress?.(stage, percent);
+        callbacksRef.current.onProgress?.(stage, percent);
+      };
+      const handleResolved = (res) => {
+        setState((prev) => ({
+          ...prev,
+          isSubmitting: false,
+          isPolling: false,
+          isLoading: false,
+          stage: "COMPLETED",
+          progress: 100,
+          result: res,
+          isSuccess: res.valid,
+          isError: !res.valid,
+          error: res.valid ? null : new Error(res.errorMessage || "Validaci\xF3n de documento fallida")
+        }));
+        input.onStatusResolved?.(res);
+        callbacksRef.current.onStatusResolved?.(res);
+      };
+      const handleError = (err) => {
+        if (err instanceof JumioAbortError) {
+          return;
+        }
+        setState((prev) => ({
+          ...prev,
+          isSubmitting: false,
+          isPolling: false,
+          isLoading: false,
+          stage: "ERROR",
+          error: err,
+          isError: true,
+          isSuccess: false
+        }));
+        input.onStatusError?.(err);
+        callbacksRef.current.onStatusError?.(err);
+      };
+      try {
+        const awaitFinal = input.awaitFinalStatus ?? false;
+        const initialResult = await client.verifyIne({
+          ...input,
+          awaitFinalStatus: awaitFinal,
+          signal: controller.signal,
+          onProgress: handleProgress,
+          onStatusResolved: (res) => {
+            handleResolved(res);
+          },
+          onStatusError: (err) => {
+            handleError(err);
+          }
+        });
+        if (!awaitFinal && initialResult.valid && !initialResult.data) {
+          setState((prev) => ({
+            ...prev,
+            isSubmitting: false,
+            isPolling: true,
+            stage: "POLLING_BACKGROUND",
+            result: initialResult
+          }));
+        } else if (!awaitFinal && initialResult.valid) {
+          setState((prev) => ({
+            ...prev,
+            isSubmitting: false,
+            isPolling: true,
+            stage: "POLLING_BACKGROUND",
+            result: initialResult
+          }));
+        }
+        return initialResult;
+      } catch (error) {
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        handleError(normalizedError);
+        throw normalizedError;
+      }
+    },
+    [client]
+  );
+  return {
+    ...state,
+    verify,
+    cancel,
+    reset,
+    client
+  };
+}
+
+exports.APPROVED_JUMIO_STATUSES = APPROVED_JUMIO_STATUSES;
+exports.FINAL_JUMIO_STATUSES = FINAL_JUMIO_STATUSES;
+exports.JumioAbortError = JumioAbortError;
+exports.JumioClient = JumioClient;
+exports.JumioError = JumioError;
+exports.JumioHttpClient = JumioHttpClient;
+exports.JumioImageProcessingError = JumioImageProcessingError;
+exports.JumioNetworkError = JumioNetworkError;
+exports.JumioPollingTimeoutError = JumioPollingTimeoutError;
+exports.JumioTimeoutError = JumioTimeoutError;
+exports.JumioValidationError = JumioValidationError;
+exports.arrayBufferToBase64 = arrayBufferToBase64;
+exports.blobToBase64 = blobToBase64;
+exports.createJumioClient = createJumioClient;
+exports.delay = delay;
+exports.extractEnvelopeData = extractEnvelopeData;
+exports.extractJumioMessage = extractJumioMessage;
+exports.extractNestedData = extractNestedData;
+exports.fetchUrlAsBase64 = fetchUrlAsBase64;
+exports.isApprovedJumioStatus = isApprovedJumioStatus;
+exports.isBase64String = isBase64String;
+exports.isFinalJumioStatus = isFinalJumioStatus;
+exports.isJumioError = isJumioError;
+exports.isPassedJumioDecision = isPassedJumioDecision;
+exports.normalizeSignedUrl = normalizeSignedUrl;
+exports.pollJumioStatus = pollJumioStatus;
+exports.resolveImageSourceToBase64 = resolveImageSourceToBase64;
+exports.resolveVerificationValidity = resolveVerificationValidity;
+exports.shouldRetryJumio = shouldRetryJumio;
+exports.stripDataUrlPrefix = stripDataUrlPrefix;
+exports.toLowerText = toLowerText;
+exports.toUpperText = toUpperText;
+exports.useJumioVerification = useJumioVerification;
+exports.withRetry = withRetry;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map