@eva_solutions/auth-sdk 0.0.0-stage → 3.0.0-dev-20261109133200

package/dist/react/index.cjs

@@ -0,0 +1,336 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_constants = require("../constants-CcbhOaAP.cjs");
+const require_error_helpers = require("../error-helpers-XCh4ZJ-g.cjs");
+const require_parse_error_response = require("../parse-error-response-6qOQS5y9.cjs");
+const require_cookies = require("../cookies-DCIcr7uy.cjs");
+const require_constants$1 = require("../constants-BE1_9Tod.cjs");
+let zod = require("zod");
+let react = require("react");
+let react_jsx_runtime = require("react/jsx-runtime");
+// src/react/auth-fetch.ts
+const ApiResponseSchema = zod.z.object({ data: zod.z.unknown().optional() });
+const FETCH_TIMEOUT = 3e4;
+const sdkError = (reason, message, status) => ({
+	kind: "sdk",
+	reason,
+	message,
+	status
+});
+const authFetch = async (url, options) => {
+	try {
+		const timeoutSignal = AbortSignal.timeout(FETCH_TIMEOUT);
+		const signal = options?.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+		const res = await fetch(url, {
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			},
+			credentials: "include",
+			signal
+		});
+		if (!res.ok) {
+			const body = await res.json().catch(() => null);
+			return {
+				ok: false,
+				error: require_parse_error_response.parseErrorResponse(res.status, body)
+			};
+		}
+		const json = await res.json();
+		const parsed = ApiResponseSchema.safeParse(json);
+		if (!parsed.success) return {
+			ok: false,
+			error: sdkError(require_error_helpers.SDK_ERROR_REASONS.malformed, "Estructura de respuesta inválida", 502)
+		};
+		return {
+			ok: true,
+			data: parsed.data.data
+		};
+	} catch (err) {
+		if (err instanceof DOMException && err.name === "TimeoutError") return {
+			ok: false,
+			error: sdkError(require_error_helpers.SDK_ERROR_REASONS.network, "Tiempo de espera agotado", 0)
+		};
+		if (err instanceof DOMException && err.name === "AbortError") return {
+			ok: false,
+			error: sdkError(require_error_helpers.SDK_ERROR_REASONS.network, "Solicitud cancelada", 0)
+		};
+		return {
+			ok: false,
+			error: sdkError(require_error_helpers.SDK_ERROR_REASONS.network, "Error de red", 0)
+		};
+	}
+};
+// src/react/eva-auth-provider.tsx
+const AuthContext = (0, react.createContext)(null);
+const useAuthContext = () => {
+	const ctx = (0, react.useContext)(AuthContext);
+	if (!ctx) throw new Error("Hook must be used within EvaAuthProvider");
+	return ctx;
+};
+const RETRY_DELAYS = [
+	1e3,
+	2e3,
+	4e3
+];
+const EvaAuthProvider = ({ children, basePath = "/auth", apiUrl, onAuthChange }) => {
+	const urlBase = (0, react.useMemo)(() => {
+		if (!apiUrl) return basePath;
+		return `${apiUrl.replace(/\/$/, "")}${basePath}`;
+	}, [apiUrl, basePath]);
+	const [state, setState] = (0, react.useState)({
+		isAuthenticated: false,
+		isLoading: true,
+		error: null
+	});
+	const prevAuthRef = (0, react.useRef)(state.isAuthenticated);
+	const onAuthChangeRef = (0, react.useRef)(onAuthChange);
+	onAuthChangeRef.current = onAuthChange;
+	(0, react.useEffect)(() => {
+		if (prevAuthRef.current !== state.isAuthenticated) {
+			prevAuthRef.current = state.isAuthenticated;
+			onAuthChangeRef.current?.(state.isAuthenticated);
+		}
+	}, [state.isAuthenticated]);
+	(0, react.useEffect)(() => {
+		const controller = new AbortController();
+		const checkSession = async () => {
+			let lastError = {
+				kind: "sdk",
+				reason: "network",
+				message: "Error de red",
+				status: 0
+			};
+			for (let attempt = 0; attempt <= RETRY_DELAYS.length; attempt++) {
+				const result = await authFetch(`${urlBase}/refresh`, {
+					method: "POST",
+					signal: controller.signal
+				});
+				if (controller.signal.aborted) return;
+				if (result.ok) {
+					setState({
+						isAuthenticated: true,
+						isLoading: false,
+						error: null
+					});
+					return;
+				}
+				if (result.error.status === 401) {
+					setState({
+						isAuthenticated: false,
+						isLoading: false,
+						error: null
+					});
+					return;
+				}
+				if (result.error.status >= 400 && result.error.status < 500) {
+					setState({
+						isAuthenticated: false,
+						isLoading: false,
+						error: result.error
+					});
+					return;
+				}
+				lastError = result.error;
+				if (attempt < RETRY_DELAYS.length) {
+					await new Promise((r) => setTimeout(r, RETRY_DELAYS[attempt]));
+					if (controller.signal.aborted) return;
+				}
+			}
+			setState({
+				isAuthenticated: false,
+				isLoading: false,
+				error: lastError
+			});
+		};
+		checkSession();
+		return () => controller.abort();
+	}, [urlBase]);
+	const setAuthenticated = (0, react.useCallback)((value) => {
+		setState((prev) => ({
+			...prev,
+			isAuthenticated: value,
+			error: null
+		}));
+	}, []);
+	const login = (0, react.useMemo)(() => ({
+		getCode: (params) => authFetch(`${urlBase}/get-code`, {
+			method: "POST",
+			body: JSON.stringify(params)
+		}),
+		verify: async (params) => {
+			const result = await authFetch(`${urlBase}/login`, {
+				method: "POST",
+				body: JSON.stringify(params)
+			});
+			if (result.ok) setState({
+				isAuthenticated: true,
+				isLoading: false,
+				error: null
+			});
+			return result;
+		}
+	}), [urlBase]);
+	const logout = (0, react.useCallback)(async () => {
+		const result = await authFetch(`${urlBase}/logout`, { method: "POST" });
+		if (result.ok) setState({
+			isAuthenticated: false,
+			isLoading: false,
+			error: null
+		});
+		return result;
+	}, [urlBase]);
+	const value = (0, react.useMemo)(() => ({
+		...state,
+		login,
+		logout,
+		setAuthenticated,
+		basePath: urlBase
+	}), [
+		state,
+		login,
+		logout,
+		setAuthenticated,
+		urlBase
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AuthContext.Provider, {
+		value,
+		children
+	});
+};
+// src/react/use-auth.ts
+const useAuth = () => {
+	const { isAuthenticated, isLoading, error, login, logout } = useAuthContext();
+	return {
+		isAuthenticated,
+		isLoading,
+		error,
+		login,
+		logout
+	};
+};
+// src/react/use-auth-data.ts
+const useAuthData = (path) => {
+	const { basePath, isAuthenticated } = useAuthContext();
+	const [data, setData] = (0, react.useState)(null);
+	const [isLoading, setIsLoading] = (0, react.useState)(false);
+	const [error, setError] = (0, react.useState)(null);
+	const controllerRef = (0, react.useRef)(null);
+	const fetchData = (0, react.useCallback)(async (signal) => {
+		setIsLoading(true);
+		setError(null);
+		try {
+			const result = await authFetch(`${basePath}${path}`, { signal });
+			if (signal?.aborted) return;
+			if (result.ok) {
+				setData(result.data);
+				setError(null);
+			} else {
+				setData(null);
+				setError(result.error);
+			}
+		} finally {
+			if (!signal?.aborted) setIsLoading(false);
+		}
+	}, [basePath, path]);
+	(0, react.useEffect)(() => {
+		if (!isAuthenticated) {
+			setData(null);
+			setIsLoading(false);
+			setError(null);
+			return;
+		}
+		controllerRef.current?.abort();
+		const controller = new AbortController();
+		controllerRef.current = controller;
+		fetchData(controller.signal);
+		return () => controller.abort();
+	}, [isAuthenticated, fetchData]);
+	return {
+		data,
+		isLoading,
+		error,
+		refetch: (0, react.useCallback)(() => {
+			controllerRef.current?.abort();
+			const controller = new AbortController();
+			controllerRef.current = controller;
+			fetchData(controller.signal);
+		}, [fetchData])
+	};
+};
+// src/react/use-user.ts
+const useUser = () => {
+	const { data: user, ...rest } = useAuthData("/me");
+	return {
+		user,
+		...rest
+	};
+};
+// src/react/use-sessions.ts
+const useSessions = () => {
+	const { basePath } = useAuthContext();
+	const { data: sessions, refetch, ...rest } = useAuthData("/sessions");
+	const closeSession = (0, react.useCallback)(async (sessionId) => {
+		const result = await authFetch(`${basePath}/sessions/${sessionId}`, { method: "DELETE" });
+		if (result.ok) refetch();
+		return result;
+	}, [basePath, refetch]);
+	const closeAllOther = (0, react.useCallback)(async () => {
+		const result = await authFetch(`${basePath}/sessions`, { method: "DELETE" });
+		if (result.ok) refetch();
+		return result;
+	}, [basePath, refetch]);
+	return {
+		sessions,
+		...rest,
+		refetch,
+		closeSession,
+		closeAllOther
+	};
+};
+// src/react/use-empresas.ts
+const useEmpresas = () => {
+	const { data: empresas, ...rest } = useAuthData("/empresas");
+	return {
+		empresas,
+		...rest
+	};
+};
+exports.COOKIE_MAX_AGE = require_constants$1.COOKIE_MAX_AGE;
+exports.DEFAULT_ERROR_MESSAGES = require_parse_error_response.DEFAULT_ERROR_MESSAGES;
+exports.ERROR_CODES = require_constants.ERROR_CODES;
+exports.EvaAuthProvider = EvaAuthProvider;
+exports.HEADERS = require_constants.HEADERS;
+exports.SDK_ERROR_REASONS = require_error_helpers.SDK_ERROR_REASONS;
+exports.authFetch = authFetch;
+exports.configureEvaAuth = require_parse_error_response.configureEvaAuth;
+exports.getCookieNames = require_constants$1.getCookieNames;
+exports.isAccountStateLocked = require_error_helpers.isAccountStateLocked;
+exports.isApiError = require_error_helpers.isApiError;
+exports.isAuthRequired = require_error_helpers.isAuthRequired;
+exports.isBadRequest = require_error_helpers.isBadRequest;
+exports.isConflict = require_error_helpers.isConflict;
+exports.isForbidden = require_error_helpers.isForbidden;
+exports.isGone = require_error_helpers.isGone;
+exports.isInternalError = require_error_helpers.isInternalError;
+exports.isMalformed = require_error_helpers.isMalformed;
+exports.isNetworkError = require_error_helpers.isNetworkError;
+exports.isNotFound = require_error_helpers.isNotFound;
+exports.isRateLimited = require_error_helpers.isRateLimited;
+exports.isRefreshNoTokens = require_error_helpers.isRefreshNoTokens;
+exports.isSdkError = require_error_helpers.isSdkError;
+exports.isServiceUnavailable = require_error_helpers.isServiceUnavailable;
+exports.isTokenInvalid = require_error_helpers.isTokenInvalid;
+exports.isUnauthorized = require_error_helpers.isUnauthorized;
+exports.isUnprocessableEntity = require_error_helpers.isUnprocessableEntity;
+exports.isValidationError = require_error_helpers.isValidationError;
+exports.isVerifyFailed = require_error_helpers.isVerifyFailed;
+exports.matchError = require_error_helpers.matchError;
+exports.matchSdkReason = require_error_helpers.matchSdkReason;
+exports.readTokensFromCookies = require_cookies.readTokensFromCookies;
+exports.useAuth = useAuth;
+exports.useEmpresas = useEmpresas;
+exports.useSessions = useSessions;
+exports.useUser = useUser;
+
+//# sourceMappingURL=index.cjs.map

package/dist/react/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["z","parseErrorResponse","SDK_ERROR_REASONS","createContext","useContext","useMemo","useState","useRef","useCallback","useState","useRef","useCallback","useCallback"],"sources":["../../src/react/auth-fetch.ts","../../src/react/eva-auth-provider.tsx","../../src/react/use-auth.ts","../../src/react/use-auth-data.ts","../../src/react/use-user.ts","../../src/react/use-sessions.ts","../../src/react/use-empresas.ts"],"sourcesContent":["import { z } from 'zod'\nimport type { Result } from '../types'\nimport type { EvaSdkError } from '../types'\nimport { SDK_ERROR_REASONS } from '../error-codes'\nimport { parseErrorResponse } from '../parse-error-response'\n\nconst ApiResponseSchema = z.object({\n  data: z.unknown().optional(),\n})\n\nconst FETCH_TIMEOUT = 30_000\n\nconst sdkError = (\n  reason: EvaSdkError['reason'],\n  message: string,\n  status: number,\n): EvaSdkError => ({\n  kind: 'sdk',\n  reason,\n  message,\n  status,\n})\n\nexport const authFetch = async <T>(\n  url: string,\n  options?: RequestInit,\n): Promise<Result<T>> => {\n  try {\n    const timeoutSignal = AbortSignal.timeout(FETCH_TIMEOUT)\n    const signal = options?.signal\n      ? AbortSignal.any([options.signal, timeoutSignal])\n      : timeoutSignal\n\n    const res = await fetch(url, {\n      ...options,\n      headers: { 'Content-Type': 'application/json', ...options?.headers },\n      credentials: 'include',\n      signal,\n    })\n\n    if (!res.ok) {\n      const body = await res.json().catch(() => null)\n      const error = parseErrorResponse(res.status, body)\n      return { ok: false, error }\n    }\n\n    const json: unknown = await res.json()\n    const parsed = ApiResponseSchema.safeParse(json)\n    if (!parsed.success) {\n      return {\n        ok: false,\n        error: sdkError(\n          SDK_ERROR_REASONS.malformed,\n          'Estructura de respuesta inválida',\n          502,\n        ),\n      }\n    }\n    return { ok: true, data: parsed.data.data as T }\n  } catch (err) {\n    if (err instanceof DOMException && err.name === 'TimeoutError') {\n      return {\n        ok: false,\n        error: sdkError(\n          SDK_ERROR_REASONS.network,\n          'Tiempo de espera agotado',\n          0,\n        ),\n      }\n    }\n    if (err instanceof DOMException && err.name === 'AbortError') {\n      return {\n        ok: false,\n        error: sdkError(SDK_ERROR_REASONS.network, 'Solicitud cancelada', 0),\n      }\n    }\n    return {\n      ok: false,\n      error: sdkError(SDK_ERROR_REASONS.network, 'Error de red', 0),\n    }\n  }\n}\n","import {\n  createContext,\n  useContext,\n  useState,\n  useEffect,\n  useCallback,\n  useRef,\n  useMemo,\n  type ReactNode,\n} from 'react'\nimport type { Result, EvaError } from '../types'\nimport { authFetch } from './auth-fetch'\n\n// ── Types ──────────────────────────────────────────────\n\nexport type AuthState = {\n  isAuthenticated: boolean\n  isLoading: boolean\n  error: EvaError | null\n}\n\nexport type AuthContextValue = AuthState & {\n  login: {\n    /**\n     * Solicita el código. El `challengeId` devuelto es opaco: consérvalo en\n     * memoria (el provider no lo guarda) y pásalo a `verify`. Cada `getCode`\n     * nuevo invalida el `challengeId` anterior.\n     */\n    getCode: (params: {\n      phone: string\n    }) => Promise<Result<{ message: string; challengeId: string }>>\n    /** Verifica el código con el `challengeId` que devolvió `getCode`. */\n    verify: (params: {\n      phone: string\n      code: string\n      challengeId: string\n    }) => Promise<Result<{ user: { id: string } }>>\n  }\n  logout: () => Promise<Result<{ message: string }>>\n  setAuthenticated: (value: boolean) => void\n  basePath: string\n}\n\nexport type EvaAuthProviderProps = {\n  children: ReactNode\n  basePath?: string\n  apiUrl?: string\n  onAuthChange?: (authenticated: boolean) => void\n}\n\n// ── Context ────────────────────────────────────────────\n\nconst AuthContext = createContext<AuthContextValue | null>(null)\n\nexport const useAuthContext = () => {\n  const ctx = useContext(AuthContext)\n  if (!ctx) throw new Error('Hook must be used within EvaAuthProvider')\n  return ctx\n}\n\n// ── Provider ───────────────────────────────────────────\n\nconst RETRY_DELAYS = [1000, 2000, 4000]\n\nexport const EvaAuthProvider = ({\n  children,\n  basePath = '/auth',\n  apiUrl,\n  onAuthChange,\n}: EvaAuthProviderProps) => {\n  const urlBase = useMemo(() => {\n    if (!apiUrl) return basePath\n    return `${apiUrl.replace(/\\/$/, '')}${basePath}`\n  }, [apiUrl, basePath])\n\n  const [state, setState] = useState<AuthState>({\n    isAuthenticated: false,\n    isLoading: true,\n    error: null,\n  })\n\n  const prevAuthRef = useRef(state.isAuthenticated)\n  const onAuthChangeRef = useRef(onAuthChange)\n  onAuthChangeRef.current = onAuthChange\n\n  // Notify on auth transitions\n  useEffect(() => {\n    if (prevAuthRef.current !== state.isAuthenticated) {\n      prevAuthRef.current = state.isAuthenticated\n      onAuthChangeRef.current?.(state.isAuthenticated)\n    }\n  }, [state.isAuthenticated])\n\n  // Silent refresh on mount\n  useEffect(() => {\n    const controller = new AbortController()\n\n    const checkSession = async () => {\n      let lastError: EvaError = {\n        kind: 'sdk',\n        reason: 'network',\n        message: 'Error de red',\n        status: 0,\n      }\n      for (let attempt = 0; attempt <= RETRY_DELAYS.length; attempt++) {\n        const result = await authFetch<unknown>(`${urlBase}/refresh`, {\n          method: 'POST',\n          signal: controller.signal,\n        })\n\n        if (controller.signal.aborted) return\n\n        if (result.ok) {\n          setState({ isAuthenticated: true, isLoading: false, error: null })\n          return\n        }\n\n        if (result.error.status === 401) {\n          setState({ isAuthenticated: false, isLoading: false, error: null })\n          return\n        }\n\n        // Errores de cliente (4xx) no son recuperables con retry\n        if (result.error.status >= 400 && result.error.status < 500) {\n          setState({\n            isAuthenticated: false,\n            isLoading: false,\n            error: result.error,\n          })\n          return\n        }\n\n        lastError = result.error\n\n        if (attempt < RETRY_DELAYS.length) {\n          await new Promise<void>((r) => setTimeout(r, RETRY_DELAYS[attempt]))\n          if (controller.signal.aborted) return\n        }\n      }\n\n      setState({\n        isAuthenticated: false,\n        isLoading: false,\n        error: lastError,\n      })\n    }\n\n    checkSession()\n    return () => controller.abort()\n  }, [urlBase])\n\n  const setAuthenticated = useCallback((value: boolean) => {\n    setState((prev) => ({ ...prev, isAuthenticated: value, error: null }))\n  }, [])\n\n  const login = useMemo(\n    () => ({\n      getCode: (params: { phone: string }) =>\n        authFetch<{ message: string; challengeId: string }>(\n          `${urlBase}/get-code`,\n          {\n            method: 'POST',\n            body: JSON.stringify(params),\n          },\n        ),\n      verify: async (params: {\n        phone: string\n        code: string\n        challengeId: string\n      }) => {\n        const result = await authFetch<{ user: { id: string } }>(\n          `${urlBase}/login`,\n          {\n            method: 'POST',\n            body: JSON.stringify(params),\n          },\n        )\n        if (result.ok)\n          setState({ isAuthenticated: true, isLoading: false, error: null })\n        return result\n      },\n    }),\n    [urlBase],\n  )\n\n  const logout = useCallback(async () => {\n    const result = await authFetch<{ message: string }>(`${urlBase}/logout`, {\n      method: 'POST',\n    })\n    if (result.ok)\n      setState({ isAuthenticated: false, isLoading: false, error: null })\n    return result\n  }, [urlBase])\n\n  const value = useMemo<AuthContextValue>(\n    () => ({\n      ...state,\n      login,\n      logout,\n      setAuthenticated,\n      basePath: urlBase,\n    }),\n    [state, login, logout, setAuthenticated, urlBase],\n  )\n\n  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>\n}\n","import { useAuthContext } from './eva-auth-provider'\n\nexport const useAuth = () => {\n  const { isAuthenticated, isLoading, error, login, logout } = useAuthContext()\n  return { isAuthenticated, isLoading, error, login, logout }\n}\n","import { useState, useEffect, useCallback, useRef } from 'react'\nimport { useAuthContext } from './eva-auth-provider'\nimport type { EvaError } from '../types'\nimport { authFetch } from './auth-fetch'\n\ntype AuthDataResult<T> = {\n  data: T | null\n  isLoading: boolean\n  error: EvaError | null\n  refetch: () => void\n}\n\nexport const useAuthData = <T>(path: string): AuthDataResult<T> => {\n  const { basePath, isAuthenticated } = useAuthContext()\n\n  const [data, setData] = useState<T | null>(null)\n  const [isLoading, setIsLoading] = useState(false)\n  const [error, setError] = useState<EvaError | null>(null)\n  const controllerRef = useRef<AbortController | null>(null)\n\n  const fetchData = useCallback(\n    async (signal?: AbortSignal) => {\n      setIsLoading(true)\n      setError(null)\n\n      try {\n        const result = await authFetch<T>(`${basePath}${path}`, { signal })\n        if (signal?.aborted) return\n\n        if (result.ok) {\n          setData(result.data)\n          setError(null)\n        } else {\n          setData(null)\n          setError(result.error)\n        }\n      } finally {\n        if (!signal?.aborted) setIsLoading(false)\n      }\n    },\n    [basePath, path],\n  )\n\n  useEffect(() => {\n    if (!isAuthenticated) {\n      setData(null)\n      setIsLoading(false)\n      setError(null)\n      return\n    }\n\n    controllerRef.current?.abort()\n    const controller = new AbortController()\n    controllerRef.current = controller\n    fetchData(controller.signal)\n    return () => controller.abort()\n  }, [isAuthenticated, fetchData])\n\n  const refetch = useCallback(() => {\n    controllerRef.current?.abort()\n    const controller = new AbortController()\n    controllerRef.current = controller\n    fetchData(controller.signal)\n  }, [fetchData])\n\n  return { data, isLoading, error, refetch }\n}\n","import type { EvaUser } from '../types'\nimport { useAuthData } from './use-auth-data'\n\nexport const useUser = () => {\n  const { data: user, ...rest } = useAuthData<EvaUser>('/me')\n  return { user, ...rest }\n}\n","import { useCallback } from 'react'\nimport type { EvaSession, Result } from '../types'\nimport { useAuthContext } from './eva-auth-provider'\nimport { useAuthData } from './use-auth-data'\nimport { authFetch } from './auth-fetch'\n\nexport const useSessions = () => {\n  const { basePath } = useAuthContext()\n  const {\n    data: sessions,\n    refetch,\n    ...rest\n  } = useAuthData<EvaSession[]>('/sessions')\n\n  const closeSession = useCallback(\n    async (sessionId: string): Promise<Result<{ message: string }>> => {\n      const result = await authFetch<{ message: string }>(\n        `${basePath}/sessions/${sessionId}`,\n        {\n          method: 'DELETE',\n        },\n      )\n      if (result.ok) refetch()\n      return result\n    },\n    [basePath, refetch],\n  )\n\n  const closeAllOther = useCallback(async (): Promise<\n    Result<{ message: string }>\n  > => {\n    const result = await authFetch<{ message: string }>(\n      `${basePath}/sessions`,\n      {\n        method: 'DELETE',\n      },\n    )\n    if (result.ok) refetch()\n    return result\n  }, [basePath, refetch])\n\n  return { sessions, ...rest, refetch, closeSession, closeAllOther }\n}\n","import type { EvaEmpresa } from '../types'\nimport { useAuthData } from './use-auth-data'\n\nexport const useEmpresas = () => {\n  const { data: empresas, ...rest } = useAuthData<EvaEmpresa[]>('/empresas')\n  return { empresas, ...rest }\n}\n"],"mappings":"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"}

package/dist/react/index.d.cts

@@ -0,0 +1,151 @@
+import { bi as ERROR_CODES, xi as HEADERS } from "../index-CZru7c5T.cjs";
+import { a as EvaError, d as Result, m as SDK_ERROR_REASONS, o as EvaSdkError, r as EvaApiError } from "../types-Ci0Jq0xB.cjs";
+import { a as COOKIE_MAX_AGE, l as readTokensFromCookies, n as configureEvaAuth, s as getCookieNames, t as ConfigureEvaAuthOptions } from "../config-3avoUa9e.cjs";
+import { n as EvaErrorMessages, t as DEFAULT_ERROR_MESSAGES } from "../error-messages-CGpW1fsg.cjs";
+import { S as matchSdkReason, _ as isUnauthorized, a as isConflict, b as isVerifyFailed, c as isInternalError, d as isNotFound, f as isRateLimited, g as isTokenInvalid, h as isServiceUnavailable, i as isBadRequest, l as isMalformed, m as isSdkError, n as isApiError, o as isForbidden, p as isRefreshNoTokens, r as isAuthRequired, s as isGone, t as isAccountStateLocked, u as isNetworkError, v as isUnprocessableEntity, x as matchError, y as isValidationError } from "../error-helpers-0woh13Wd.cjs";
+import { ReactNode } from "react";
+type AuthState = {
+  isAuthenticated: boolean;
+  isLoading: boolean;
+  error: EvaError | null;
+};
+type AuthContextValue = AuthState & {
+  login: {
+    /**
+     * Solicita el código. El `challengeId` devuelto es opaco: consérvalo en
+     * memoria (el provider no lo guarda) y pásalo a `verify`. Cada `getCode`
+     * nuevo invalida el `challengeId` anterior.
+     */
+    getCode: (params: {
+      phone: string;
+    }) => Promise<Result<{
+      message: string;
+      challengeId: string;
+    }>>;
+    /** Verifica el código con el `challengeId` que devolvió `getCode`. */
+    verify: (params: {
+      phone: string;
+      code: string;
+      challengeId: string;
+    }) => Promise<Result<{
+      user: {
+        id: string;
+      };
+    }>>;
+  };
+  logout: () => Promise<Result<{
+    message: string;
+  }>>;
+  setAuthenticated: (value: boolean) => void;
+  basePath: string;
+};
+type EvaAuthProviderProps = {
+  children: ReactNode;
+  basePath?: string;
+  apiUrl?: string;
+  onAuthChange?: (authenticated: boolean) => void;
+};
+declare const EvaAuthProvider: ({ children, basePath, apiUrl, onAuthChange }: EvaAuthProviderProps) => import("react").JSX.Element;
+declare const useAuth: () => {
+  isAuthenticated: boolean;
+  isLoading: boolean;
+  error: EvaError | null;
+  login: {
+    getCode: (params: {
+      phone: string;
+    }) => Promise<Result<{
+      message: string;
+      challengeId: string;
+    }>>;
+    verify: (params: {
+      phone: string;
+      code: string;
+      challengeId: string;
+    }) => Promise<Result<{
+      user: {
+        id: string;
+      };
+    }>>;
+  };
+  logout: () => Promise<Result<{
+    message: string;
+  }>>;
+};
+declare const useUser: () => {
+  isLoading: boolean;
+  error: EvaError | null;
+  refetch: () => void;
+  user: {
+    id: string;
+    phone: string;
+    name: string | null;
+    lastName: string | null;
+    email: string | null;
+    dni: string | null;
+    stateActivity: "activo" | "ausente" | "ocupado" | "desconectado";
+    statePrivacy: "publico" | "amigos" | "invisible";
+    createdAt: string;
+  } | null;
+};
+declare const useSessions: () => {
+  refetch: () => void;
+  closeSession: (sessionId: string) => Promise<Result<{
+    message: string;
+  }>>;
+  closeAllOther: () => Promise<Result<{
+    message: string;
+  }>>;
+  isLoading: boolean;
+  error: EvaError | null;
+  sessions: {
+    sessionId: string;
+    deviceType: string;
+    os: string;
+    browser: string;
+    ipAddress: string;
+    createdAt: string;
+    current: boolean;
+  }[] | null;
+};
+declare const useEmpresas: () => {
+  isLoading: boolean;
+  error: EvaError | null;
+  refetch: () => void;
+  empresas: ({
+    contratado: true;
+    direccion: string | null;
+    celular: string | null;
+    email: string | null;
+    img: string | null;
+    sucursales: {
+      id: string;
+      empresaId: string;
+      nombre: string;
+      direccion: string | null;
+      activa: boolean;
+    }[];
+    id: string;
+    ruc: string;
+    razonSocial: string;
+    slug: string;
+    rol: "titular" | "administrador" | "miembro";
+    grupo: {
+      id: string;
+      nombre: string;
+    } | null;
+  } | {
+    contratado: false;
+    id: string;
+    ruc: string;
+    razonSocial: string;
+    slug: string;
+    rol: "titular" | "administrador" | "miembro";
+    grupo: {
+      id: string;
+      nombre: string;
+    } | null;
+  })[] | null;
+};
+declare const authFetch: <T>(url: string, options?: RequestInit) => Promise<Result<T>>;
+export { type AuthContextValue, type AuthState, COOKIE_MAX_AGE, type ConfigureEvaAuthOptions, DEFAULT_ERROR_MESSAGES, ERROR_CODES, type EvaApiError, EvaAuthProvider, type EvaAuthProviderProps, type EvaError, type EvaErrorMessages, type EvaSdkError, HEADERS, type Result, SDK_ERROR_REASONS, authFetch, configureEvaAuth, getCookieNames, isAccountStateLocked, isApiError, isAuthRequired, isBadRequest, isConflict, isForbidden, isGone, isInternalError, isMalformed, isNetworkError, isNotFound, isRateLimited, isRefreshNoTokens, isSdkError, isServiceUnavailable, isTokenInvalid, isUnauthorized, isUnprocessableEntity, isValidationError, isVerifyFailed, matchError, matchSdkReason, readTokensFromCookies, useAuth, useEmpresas, useSessions, useUser };
+//# sourceMappingURL=index.d.cts.map

package/dist/react/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["_$_0.EvaError","_$_0.Result","_$_0.EvaError","_$_0.EvaError","_$_0.EvaError"],"sources":["../../src/react/eva-auth-provider.tsx","../../src/react/use-auth.ts","../../src/react/use-user.ts","../../src/react/use-sessions.ts","../../src/react/use-empresas.ts","../../src/react/auth-fetch.ts"],"mappings":";;;;;;KAeY;EACV;EACA;EACA,OAAO;;KAGG,mBAAmB;EAC7B;;;;;;IAME,UAAU;MACR;UACI,QAAQ;MAAS;MAAiB;;;IAExC,SAAS;MACP;MACA;MACA;UACI,QAAQ;MAAS;QAAQ;;;;EAEjC,cAAc,QAAQ;IAAS;;EAC/B,mBAAmB;EACnB;;KAGU;EACV,UAAU;EACV;EACA;EACA,gBAAgB;;cAiBL,oBAAmB,UAAA,UAAA,QAAA,gBAK7B,yCAAoB,IAAA;cCnEV;;;E,OAAAA;;;;;;;;;;;;;;;;;;;;;;cCCA;;E,OAAAE;;;;;;;;;;;;;;cCGA;;EASS,eAAA,sBAAS,QAAQ;IAAS;;EAaF,qBAAA,QAC1C;IAAS;;;E,OADiCC;;;;;;;;;;;cCzBjC;;E,OAAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCoBA,YAAmB,GAC9B,aACA,UAAU,gBACT,QAAQ,OAAO"}

package/dist/react/index.d.ts

@@ -0,0 +1,151 @@
+import { bi as ERROR_CODES, xi as HEADERS } from "../index-CZru7c5T.js";
+import { a as EvaError, d as Result, m as SDK_ERROR_REASONS, o as EvaSdkError, r as EvaApiError } from "../types-CEABh1Zf.js";
+import { a as COOKIE_MAX_AGE, l as readTokensFromCookies, n as configureEvaAuth, s as getCookieNames, t as ConfigureEvaAuthOptions } from "../config-COX7rGAP.js";
+import { n as EvaErrorMessages, t as DEFAULT_ERROR_MESSAGES } from "../error-messages-CGpW1fsg.js";
+import { S as matchSdkReason, _ as isUnauthorized, a as isConflict, b as isVerifyFailed, c as isInternalError, d as isNotFound, f as isRateLimited, g as isTokenInvalid, h as isServiceUnavailable, i as isBadRequest, l as isMalformed, m as isSdkError, n as isApiError, o as isForbidden, p as isRefreshNoTokens, r as isAuthRequired, s as isGone, t as isAccountStateLocked, u as isNetworkError, v as isUnprocessableEntity, x as matchError, y as isValidationError } from "../error-helpers-Ct3AUK1I.js";
+import { ReactNode } from "react";
+type AuthState = {
+  isAuthenticated: boolean;
+  isLoading: boolean;
+  error: EvaError | null;
+};
+type AuthContextValue = AuthState & {
+  login: {
+    /**
+     * Solicita el código. El `challengeId` devuelto es opaco: consérvalo en
+     * memoria (el provider no lo guarda) y pásalo a `verify`. Cada `getCode`
+     * nuevo invalida el `challengeId` anterior.
+     */
+    getCode: (params: {
+      phone: string;
+    }) => Promise<Result<{
+      message: string;
+      challengeId: string;
+    }>>;
+    /** Verifica el código con el `challengeId` que devolvió `getCode`. */
+    verify: (params: {
+      phone: string;
+      code: string;
+      challengeId: string;
+    }) => Promise<Result<{
+      user: {
+        id: string;
+      };
+    }>>;
+  };
+  logout: () => Promise<Result<{
+    message: string;
+  }>>;
+  setAuthenticated: (value: boolean) => void;
+  basePath: string;
+};
+type EvaAuthProviderProps = {
+  children: ReactNode;
+  basePath?: string;
+  apiUrl?: string;
+  onAuthChange?: (authenticated: boolean) => void;
+};
+declare const EvaAuthProvider: ({ children, basePath, apiUrl, onAuthChange }: EvaAuthProviderProps) => import("react").JSX.Element;
+declare const useAuth: () => {
+  isAuthenticated: boolean;
+  isLoading: boolean;
+  error: EvaError | null;
+  login: {
+    getCode: (params: {
+      phone: string;
+    }) => Promise<Result<{
+      message: string;
+      challengeId: string;
+    }>>;
+    verify: (params: {
+      phone: string;
+      code: string;
+      challengeId: string;
+    }) => Promise<Result<{
+      user: {
+        id: string;
+      };
+    }>>;
+  };
+  logout: () => Promise<Result<{
+    message: string;
+  }>>;
+};
+declare const useUser: () => {
+  isLoading: boolean;
+  error: EvaError | null;
+  refetch: () => void;
+  user: {
+    id: string;
+    phone: string;
+    name: string | null;
+    lastName: string | null;
+    email: string | null;
+    dni: string | null;
+    stateActivity: "activo" | "ausente" | "ocupado" | "desconectado";
+    statePrivacy: "publico" | "amigos" | "invisible";
+    createdAt: string;
+  } | null;
+};
+declare const useSessions: () => {
+  refetch: () => void;
+  closeSession: (sessionId: string) => Promise<Result<{
+    message: string;
+  }>>;
+  closeAllOther: () => Promise<Result<{
+    message: string;
+  }>>;
+  isLoading: boolean;
+  error: EvaError | null;
+  sessions: {
+    sessionId: string;
+    deviceType: string;
+    os: string;
+    browser: string;
+    ipAddress: string;
+    createdAt: string;
+    current: boolean;
+  }[] | null;
+};
+declare const useEmpresas: () => {
+  isLoading: boolean;
+  error: EvaError | null;
+  refetch: () => void;
+  empresas: ({
+    contratado: true;
+    direccion: string | null;
+    celular: string | null;
+    email: string | null;
+    img: string | null;
+    sucursales: {
+      id: string;
+      empresaId: string;
+      nombre: string;
+      direccion: string | null;
+      activa: boolean;
+    }[];
+    id: string;
+    ruc: string;
+    razonSocial: string;
+    slug: string;
+    rol: "titular" | "administrador" | "miembro";
+    grupo: {
+      id: string;
+      nombre: string;
+    } | null;
+  } | {
+    contratado: false;
+    id: string;
+    ruc: string;
+    razonSocial: string;
+    slug: string;
+    rol: "titular" | "administrador" | "miembro";
+    grupo: {
+      id: string;
+      nombre: string;
+    } | null;
+  })[] | null;
+};
+declare const authFetch: <T>(url: string, options?: RequestInit) => Promise<Result<T>>;
+export { type AuthContextValue, type AuthState, COOKIE_MAX_AGE, type ConfigureEvaAuthOptions, DEFAULT_ERROR_MESSAGES, ERROR_CODES, type EvaApiError, EvaAuthProvider, type EvaAuthProviderProps, type EvaError, type EvaErrorMessages, type EvaSdkError, HEADERS, type Result, SDK_ERROR_REASONS, authFetch, configureEvaAuth, getCookieNames, isAccountStateLocked, isApiError, isAuthRequired, isBadRequest, isConflict, isForbidden, isGone, isInternalError, isMalformed, isNetworkError, isNotFound, isRateLimited, isRefreshNoTokens, isSdkError, isServiceUnavailable, isTokenInvalid, isUnauthorized, isUnprocessableEntity, isValidationError, isVerifyFailed, matchError, matchSdkReason, readTokensFromCookies, useAuth, useEmpresas, useSessions, useUser };
+//# sourceMappingURL=index.d.ts.map

package/dist/react/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["_$_0.EvaError","_$_0.Result","_$_0.EvaError","_$_0.EvaError","_$_0.EvaError"],"sources":["../../src/react/eva-auth-provider.tsx","../../src/react/use-auth.ts","../../src/react/use-user.ts","../../src/react/use-sessions.ts","../../src/react/use-empresas.ts","../../src/react/auth-fetch.ts"],"mappings":";;;;;;KAeY;EACV;EACA;EACA,OAAO;;KAGG,mBAAmB;EAC7B;;;;;;IAME,UAAU;MACR;UACI,QAAQ;MAAS;MAAiB;;;IAExC,SAAS;MACP;MACA;MACA;UACI,QAAQ;MAAS;QAAQ;;;;EAEjC,cAAc,QAAQ;IAAS;;EAC/B,mBAAmB;EACnB;;KAGU;EACV,UAAU;EACV;EACA;EACA,gBAAgB;;cAiBL,oBAAmB,UAAA,UAAA,QAAA,gBAK7B,yCAAoB,IAAA;cCnEV;;;E,OAAAA;;;;;;;;;;;;;;;;;;;;;;cCCA;;E,OAAAE;;;;;;;;;;;;;;cCGA;;EASS,eAAA,sBAAS,QAAQ;IAAS;;EAaF,qBAAA,QAC1C;IAAS;;;E,OADiCC;;;;;;;;;;;cCzBjC;;E,OAAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCoBA,YAAmB,GAC9B,aACA,UAAU,gBACT,QAAQ,OAAO"}