@navegarti/rn-design-system 0.8.6 → 0.8.7

package/lib/module/components/Carousel/components/see-all-button.js

@@ -7,6 +7,7 @@ import { SeeAllButton } from "../styles.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const CarouselSeeAllButton = ({
   color,
+  text = 'Ver todos',
   ...props
 }) => {
   return /*#__PURE__*/_jsxs(SeeAllButton, {
@@ -14,7 +15,7 @@ const CarouselSeeAllButton = ({
     children: [/*#__PURE__*/_jsx(Text, {
       weight: "bold",
       color: color ?? '#014661',
-      children: "Ver todos"
+      children: text
     }), /*#__PURE__*/_jsx(FontAwesomeIcon, {
       icon: faChevronRight,
       size: 12,

package/lib/module/index.js

@@ -13,7 +13,7 @@
 
 // API
 export { ApiError, AuthError, NetworkError, NotFoundError, RateLimitError, ServerError, TimeoutError, ValidationError } from "./api/errors.js";
-export { AxiosAdapter, apiRequest, useAuthStore } from "./api/index.js";
+export { apiRequest, NitroAdapter, useAuthStore } from "./api/index.js";
 // Components
 export { Button } from "./components/Button/index.js";
 export { Card } from "./components/Card/index.js";

package/lib/typescript/src/api/errors.d.ts

@@ -1,63 +1,146 @@
 /**
- * Base class for all API errors
- * Provides common structure and debugging information
+ * Base class for all API errors.
+ * Provides common structure and debugging information for HTTP-layer failures.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await api.get('/users/me');
+ * } catch (error) {
+ *   if (error instanceof ApiError) {
+ *     console.error(error.toDebugString());
+ *   }
+ * }
+ * ```
  */
 export declare class ApiError extends Error {
+    /** HTTP status code associated with the error (0 for network-layer failures). */
     readonly statusCode: number;
+    /** URL of the request that produced this error. */
     readonly url?: string;
+    /** HTTP method of the request that produced this error. */
     readonly method?: string;
+    /** Timestamp at which the error was created. */
     readonly timestamp: Date;
+    /**
+     * @param message Human-readable error description.
+     * @param statusCode HTTP status code (0 for network-level errors).
+     * @param url Request URL, if available.
+     * @param method HTTP method, if available.
+     */
     constructor(message: string, statusCode: number, url?: string, method?: string);
     /**
-     * Returns a formatted error message for debugging
+     * Returns a formatted multi-line string with all error details, useful for
+     * logging and debugging.
+     *
+     * @example
+     * ```ts
+     * console.error(error.toDebugString());
+     * // [AuthError] Unauthorized
+     * // Status: 401
+     * // URL: /users/me
+     * // Method: GET
+     * // Time: 2026-05-06T12:00:00.000Z
+     * ```
      */
     toDebugString(): string;
 }
 /**
- * Network-related errors (no internet, DNS failure, timeout)
- * HTTP Status: N/A (network layer)
+ * Network-layer errors: no internet connection, DNS failure, or connection refused.
+ * HTTP Status: N/A (statusCode is always 0).
  */
 export declare class NetworkError extends ApiError {
+    /**
+     * @param message Human-readable description of the network failure.
+     * @param url Request URL, if available.
+     * @param method HTTP method, if available.
+     */
     constructor(message: string, url?: string, method?: string);
 }
 /**
- * Authentication errors (401, 403)
- * Client lacks valid credentials or permissions
+ * Authentication or authorisation errors (401, 403).
+ * The client either lacks valid credentials or does not have permission.
+ *
+ * On a **401**, the {@link NitroAdapter} automatically clears the stored
+ * auth token before throwing this error.
+ *
+ * @param message Human-readable description.
+ * @param statusCode 401 or 403.
+ * @param url Request URL, if available.
+ * @param method HTTP method, if available.
  */
 export declare class AuthError extends ApiError {
 }
 /**
- * Client validation errors (400, 422)
- * Request malformed or validation failed
+ * Client validation errors (400, 422).
+ * The request was malformed or failed server-side validation.
  */
 export declare class ValidationError extends ApiError {
+    /** Field-level validation error messages keyed by field name. */
     readonly validationErrors?: Record<string, string[]>;
+    /**
+     * @param message Human-readable summary.
+     * @param statusCode 400 or 422.
+     * @param url Request URL, if available.
+     * @param method HTTP method, if available.
+     * @param validationErrors Optional map of field names to their error messages.
+     */
     constructor(message: string, statusCode: number, url?: string, method?: string, validationErrors?: Record<string, string[]>);
 }
 /**
- * Server errors (500, 502, 503, 504)
- * Something went wrong on the server
+ * Server errors (500, 502, 503, 504).
+ * Something went wrong on the server side.
+ *
+ * @param message Human-readable description.
+ * @param statusCode 5xx status code.
+ * @param url Request URL, if available.
+ * @param method HTTP method, if available.
  */
 export declare class ServerError extends ApiError {
 }
 /**
- * Request timeout errors
- * Request took too long to complete
+ * Request timeout errors.
+ * The server did not respond within the configured timeout window.
+ * HTTP Status: 408.
  */
 export declare class TimeoutError extends ApiError {
+    /**
+     * @param message Human-readable description.
+     * @param url Request URL, if available.
+     * @param method HTTP method, if available.
+     */
     constructor(message: string, url?: string, method?: string);
 }
 /**
- * Resource not found errors (404)
+ * Resource not found errors.
+ * HTTP Status: 404.
  */
 export declare class NotFoundError extends ApiError {
+    /**
+     * @param message Human-readable description.
+     * @param url Request URL, if available.
+     * @param method HTTP method, if available.
+     */
     constructor(message: string, url?: string, method?: string);
 }
 /**
- * Rate limit errors (429)
+ * Rate limit errors.
+ * The server has rejected the request because too many have been sent.
+ * HTTP Status: 429.
  */
 export declare class RateLimitError extends ApiError {
+    /**
+     * Number of seconds to wait before retrying, as advertised by the server
+     * in the `Retry-After` response header. May be `undefined` if the header
+     * was absent.
+     */
     readonly retryAfter?: number;
+    /**
+     * @param message Human-readable description.
+     * @param url Request URL, if available.
+     * @param method HTTP method, if available.
+     * @param retryAfter Seconds until the rate limit resets, if provided by the server.
+     */
     constructor(message: string, url?: string, method?: string, retryAfter?: number);
 }
 //# sourceMappingURL=errors.d.ts.map

package/lib/typescript/src/api/index.d.ts

@@ -1,21 +1,22 @@
-import { AxiosAdapter } from './axios-adapter';
+import { NitroAdapter } from './nitro-adapter';
 /**
- * Default API request instance
- * Pre-configured with default settings
+ * Pre-configured default adapter instance.
  *
- * Usage:
- * ```typescript
- * import { apiRequest } from '@navegarti/rn-design-system/api';
+ * The `baseURL` placeholder is intentionally generic — consuming applications
+ * should create their own instance (or override it) with their actual API URL:
  *
- * const response = await apiRequest.get<User>('/users/123');
- * if (response.success) {
- *   console.log(response.data);
- * }
+ * ```ts
+ * import { NitroAdapter } from '@navegarti/rn-design-system/api';
+ *
+ * export const api = new NitroAdapter({
+ *   baseURL: 'https://api.myapp.com',
+ *   timeout: 10_000,
+ * });
  * ```
  */
-export declare const apiRequest: AxiosAdapter;
-export { AxiosAdapter } from './axios-adapter';
+export declare const apiRequest: NitroAdapter;
 export * from './errors';
+export { NitroAdapter } from './nitro-adapter';
 export { useAuthStore } from './stores/auth-store';
 export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/api/nitro-adapter.d.ts

@@ -0,0 +1,121 @@
+import type { ApiConfig, IHttpAdapter, RequestConfig } from './types';
+/**
+ * HTTP adapter powered by react-native-nitro-fetch.
+ *
+ * Features:
+ * - Automatic `Authorization: Bearer` token injection from the Zustand auth store.
+ * - Exponential back-off retry for transient failures (408, 429, 5xx).
+ * - AbortController-based request timeout with configurable duration.
+ * - Automatic 401 logout — clears the auth token so store subscribers can redirect.
+ * - Typed error hierarchy for precise error handling at call sites.
+ *
+ * @example
+ * ```ts
+ * const api = new NitroAdapter({ baseURL: 'https://api.example.com' });
+ * api.addToken(accessToken);
+ *
+ * const user = await api.get<User>('/users/me');
+ * const post = await api.post<Post>('/posts', { title: 'Hello world' });
+ * ```
+ */
+export declare class NitroAdapter implements IHttpAdapter {
+    private readonly baseURL;
+    private readonly timeout;
+    private readonly defaultHeaders;
+    private readonly retryConfig;
+    /**
+     * @param config Adapter configuration: base URL, timeout, retry attempts,
+     *   and optional default headers merged into every request.
+     */
+    constructor(config: ApiConfig);
+    /**
+     * Resolves a path or a full URL.
+     * Full URLs (starting with `http`) are used as-is; relative paths are
+     * prefixed with `baseURL`.
+     */
+    private resolveUrl;
+    /**
+     * Builds the merged headers object for a single request.
+     * Merge priority (lowest → highest): defaults → auth token → per-request overrides.
+     * The token is read fresh from the auth store on every call.
+     */
+    private buildHeaders;
+    /**
+     * Wraps the nitro-fetch `fetch` call with an AbortController-based timeout.
+     *
+     * - Throws {@link TimeoutError} when **our** timeout fires.
+     * - Propagates a user-provided `AbortSignal` so both explicit cancellation
+     *   and timeout work simultaneously.
+     * - Re-throws any other error untouched.
+     */
+    private performFetch;
+    /**
+     * Reads a failed response body and throws the appropriate typed error.
+     *
+     * On **401 Unauthorized**, the auth token is cleared before throwing
+     * {@link AuthError} so that any Zustand subscriber watching `token` can
+     * redirect the user to the login screen automatically.
+     *
+     * @returns This method always throws — it never resolves.
+     */
+    private parseErrorResponse;
+    /**
+     * Core request runner: resolves the URL, builds headers, executes the
+     * request with retry logic, and parses the response into `T`.
+     *
+     * A user-initiated `AbortError` (signal not caused by our timeout) is
+     * surfaced as a {@link NetworkError} with the message "Request was cancelled".
+     */
+    private executeRequest;
+    /**
+     * Performs a GET request.
+     *
+     * @template T Expected response body type.
+     * @param url Request path or full URL.
+     * @param config Optional per-request overrides (headers, signal, cache, credentials).
+     */
+    get<T = unknown>(url: string, config?: RequestConfig): Promise<T>;
+    /**
+     * Performs a POST request.
+     *
+     * @template T Expected response body type.
+     * @param url Request path or full URL.
+     * @param data Request body — will be JSON-serialised if provided.
+     * @param config Optional per-request overrides.
+     */
+    post<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<T>;
+    /**
+     * Performs a PUT request.
+     *
+     * @template T Expected response body type.
+     * @param url Request path or full URL.
+     * @param data Request body — will be JSON-serialised if provided.
+     * @param config Optional per-request overrides.
+     */
+    put<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<T>;
+    /**
+     * Performs a DELETE request.
+     *
+     * @template T Expected response body type.
+     * @param url Request path or full URL.
+     * @param config Optional per-request overrides.
+     */
+    delete<T = unknown>(url: string, config?: RequestConfig): Promise<T>;
+    /**
+     * Stores an auth token and attaches it as `Authorization: Bearer <token>`
+     * on all subsequent requests.
+     *
+     * @param token Bearer token value.
+     */
+    addToken(token: string): void;
+    /**
+     * Clears the stored auth token, preventing it from being sent on
+     * subsequent requests.
+     */
+    removeToken(): void;
+    /**
+     * Returns the currently stored auth token, or `null` if none is set.
+     */
+    getToken(): string | null;
+}
+//# sourceMappingURL=nitro-adapter.d.ts.map

package/lib/typescript/src/api/retry-strategy.d.ts

@@ -1,21 +1,40 @@
-import type { AxiosError } from 'axios';
 import type { RetryConfig } from './types';
 /**
- * Calculates exponential backoff delay
- * Formula: min(baseDelay * (2 ^ attempt), maxDelay)
+ * Calculates exponential back-off delay.
+ * Formula: `min(baseDelay × 2^attempt, maxDelay)`
+ *
+ * @param attempt Zero-based attempt index.
+ * @param baseDelay Starting delay in milliseconds.
+ * @param maxDelay Upper ceiling for the delay in milliseconds.
  */
 export declare function calculateBackoffDelay(attempt: number, baseDelay: number, maxDelay: number): number;
 /**
- * Determines if an error is retryable based on configuration
+ * Determines whether an error should trigger another retry attempt.
+ *
+ * Uses duck-typing on the `statusCode` property so it works with any
+ * error class that carries an HTTP status code — no dependency on a
+ * specific HTTP library's error type.
+ *
+ * @param error The thrown error.
+ * @param retryConfig Retry configuration.
  */
-export declare function isRetryableError(error: AxiosError, retryConfig: RetryConfig): boolean;
+export declare function isRetryableError(error: Error, retryConfig: RetryConfig): boolean;
 /**
- * Sleep utility for retry delays
+ * Pauses execution for the specified duration.
+ *
+ * @param ms Duration in milliseconds.
  */
 export declare function sleep(ms: number): Promise<void>;
 /**
- * Executes a request with retry logic
- * @template T - The expected response type
+ * Executes `requestFn` with exponential back-off retry logic.
+ * Retries only when `isRetryableError` returns `true` and there are
+ * remaining attempts.
+ *
+ * @template T The expected resolved type of `requestFn`.
+ * @param requestFn Async function to call on each attempt.
+ * @param retryConfig Retry strategy configuration.
+ * @param onRetry Optional callback invoked before each retry,
+ *   receiving the attempt number (1-based), delay in ms, and the error.
  */
-export declare function executeWithRetry<T>(requestFn: () => Promise<T>, retryConfig: RetryConfig, onRetry?: (attempt: number, delay: number, error: AxiosError) => void): Promise<T>;
+export declare function executeWithRetry<T>(requestFn: () => Promise<T>, retryConfig: RetryConfig, onRetry?: (attempt: number, delay: number, error: Error) => void): Promise<T>;
 //# sourceMappingURL=retry-strategy.d.ts.map

package/lib/typescript/src/api/stores/auth-store.d.ts

@@ -1,14 +1,37 @@
 /**
- * Authentication store state
+ * Shape of the authentication store state.
  */
 interface AuthState {
+    /** The current Bearer token, or `null` when the user is not authenticated. */
     token: string | null;
+    /**
+     * Stores a new auth token.
+     * @param token Bearer token received after a successful login or refresh.
+     */
     setToken: (token: string) => void;
+    /**
+     * Clears the stored token, effectively logging the user out.
+     * Called automatically by {@link NitroAdapter} when a 401 response is received.
+     */
     clearToken: () => void;
 }
 /**
- * Zustand store for managing authentication token
- * Token is stored in memory and used for Authorization header
+ * Zustand store for managing the authentication token.
+ *
+ * The token is kept in memory and automatically injected as an
+ * `Authorization: Bearer` header by {@link NitroAdapter} on every request.
+ *
+ * Subscribe to `token` changes to trigger navigation to the login screen
+ * when the user is logged out:
+ *
+ * ```ts
+ * useAuthStore.subscribe(
+ *   (state) => state.token,
+ *   (token) => {
+ *     if (!token) navigation.replace('Login');
+ *   },
+ * );
+ * ```
  */
 export declare const useAuthStore: import("zustand").UseBoundStore<import("zustand").StoreApi<AuthState>>;
 export {};

package/lib/typescript/src/api/types.d.ts

@@ -1,58 +1,92 @@
-import type { AxiosRequestConfig } from 'axios';
 /**
- * Configuration options for API adapter
+ * Configuration options for the API adapter.
  */
 export interface ApiConfig {
+    /** Base URL prepended to all relative request paths. */
     baseURL: string;
+    /** Request timeout in milliseconds. Defaults to 30 000 (30 s). */
     timeout?: number;
+    /** Maximum number of retry attempts on transient failures. Defaults to 3. */
     retryAttempts?: number;
+    /** Default headers merged into every request. */
     headers?: Record<string, string>;
 }
 /**
- * Interface for HTTP client adapter
- * Defines the contract all HTTP adapters must implement
+ * Per-request configuration options accepted by each HTTP method.
+ */
+export interface RequestConfig {
+    /** Extra headers merged on top of the adapter's default headers. */
+    headers?: Record<string, string>;
+    /** AbortSignal for explicit request cancellation via AbortController. */
+    signal?: AbortSignal;
+    /**
+     * Cache directive forwarded to the underlying fetch call.
+     * Supported by react-native-nitro-fetch via Cronet / URLSession.
+     */
+    cache?: 'default' | 'force-cache' | 'no-cache' | 'no-store' | 'only-if-cached' | 'reload';
+    /** Credentials mode for cross-origin requests. */
+    credentials?: 'include' | 'omit' | 'same-origin';
+}
+/**
+ * Contract every HTTP adapter implementation must satisfy.
  */
 export interface IHttpAdapter {
     /**
-     * Performs a GET request
-     * @template T - Expected response data type
+     * Performs a GET request.
+     * @template T Expected response body type.
+     * @param url Request path or full URL.
+     * @param config Optional per-request overrides.
      */
-    get<T = unknown>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    get<T = unknown>(url: string, config?: RequestConfig): Promise<T>;
     /**
-     * Performs a POST request
-     * @template T - Expected response data type
+     * Performs a POST request.
+     * @template T Expected response body type.
+     * @param url Request path or full URL.
+     * @param data Request body — will be JSON-serialised.
+     * @param config Optional per-request overrides.
      */
-    post<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T>;
+    post<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<T>;
     /**
-     * Performs a PUT request
-     * @template T - Expected response data type
+     * Performs a PUT request.
+     * @template T Expected response body type.
+     * @param url Request path or full URL.
+     * @param data Request body — will be JSON-serialised.
+     * @param config Optional per-request overrides.
      */
-    put<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T>;
+    put<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<T>;
     /**
-     * Performs a DELETE request
-     * @template T - Expected response data type
+     * Performs a DELETE request.
+     * @template T Expected response body type.
+     * @param url Request path or full URL.
+     * @param config Optional per-request overrides.
      */
-    delete<T = unknown>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    delete<T = unknown>(url: string, config?: RequestConfig): Promise<T>;
     /**
-     * Adds authentication token to all subsequent requests
+     * Stores an auth token that will be injected as `Authorization: Bearer <token>`
+     * on every subsequent request.
+     * @param token Bearer token value.
      */
     addToken(token: string): void;
     /**
-     * Removes authentication token from requests
+     * Clears the stored auth token, preventing it from being sent on subsequent requests.
      */
     removeToken(): void;
     /**
-     * Get token from store
+     * Returns the currently stored auth token, or `null` if none is set.
      */
     getToken(): string | null;
 }
 /**
- * Retry configuration
+ * Configuration for the exponential back-off retry strategy.
  */
 export interface RetryConfig {
+    /** Maximum number of attempts including the first try. */
     maxAttempts: number;
+    /** Base delay in milliseconds between retries. */
     baseDelay: number;
+    /** Upper bound on the calculated back-off delay, in milliseconds. */
     maxDelay: number;
+    /** HTTP status codes that trigger a retry. */
     retryableStatusCodes: number[];
 }
 //# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/api.d.ts

@@ -3,6 +3,6 @@
  * Exports HTTP client, types, errors, and stores.
  */
 export { ApiError, AuthError, NetworkError, NotFoundError, RateLimitError, ServerError, TimeoutError, ValidationError, } from './api/errors';
-export { AxiosAdapter, apiRequest, useAuthStore } from './api/index';
-export type { ApiConfig, IHttpAdapter } from './api/types';
+export { apiRequest, NitroAdapter, useAuthStore } from './api/index';
+export type { ApiConfig, IHttpAdapter, RequestConfig } from './api/types';
 //# sourceMappingURL=api.d.ts.map