@navegarti/rn-design-system 0.8.6 → 0.8.7

package/src/api/retry-strategy.ts

@@ -1,39 +1,54 @@
-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 function calculateBackoffDelay(
   attempt: number,
   baseDelay: number,
   maxDelay: number,
 ): number {
-  const exponentialDelay = baseDelay * 2 ** attempt;
-  return Math.min(exponentialDelay, maxDelay);
+  return Math.min(baseDelay * 2 ** attempt, maxDelay);
 }
 
 /**
- * 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 function isRetryableError(
-  error: AxiosError,
+  error: Error,
   retryConfig: RetryConfig,
 ): boolean {
-  // Network errors (no response) are always retryable
-  if (!error.response) {
-    return true;
+  const statusCode = (error as { statusCode?: number }).statusCode;
+
+  // Unknown error type (e.g. user-initiated AbortError) — do not retry.
+  if (statusCode === undefined) {
+    return false;
   }
 
-  const statusCode = error.response.status;
+  // Network-layer errors (statusCode 0) are always retried.
+  if (statusCode === 0) {
+    return true;
+  }
 
-  // Check if status code is in retryable list
   return retryConfig.retryableStatusCodes.includes(statusCode);
 }
 
 /**
- * Sleep utility for retry delays
+ * Pauses execution for the specified duration.
+ *
+ * @param ms Duration in milliseconds.
  */
 export function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => {
@@ -42,45 +57,49 @@ export 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 async function executeWithRetry<T>(
   requestFn: () => Promise<T>,
   retryConfig: RetryConfig,
-  onRetry?: (attempt: number, delay: number, error: AxiosError) => void,
+  onRetry?: (attempt: number, delay: number, error: Error) => void,
 ): Promise<T> {
-  let lastError: AxiosError | undefined;
+  let lastError: Error | undefined;
 
   for (let attempt = 0; attempt < retryConfig.maxAttempts; attempt++) {
     try {
       return await requestFn();
     } catch (error) {
-      const axiosError = error as AxiosError;
-      lastError = axiosError;
+      const err = error as Error;
+      lastError = err;
 
-      // Don't retry if not retryable or if this was the last attempt
       const isLastAttempt = attempt === retryConfig.maxAttempts - 1;
-      if (!isRetryableError(axiosError, retryConfig) || isLastAttempt) {
-        throw error;
+      if (!isRetryableError(err, retryConfig) || isLastAttempt) {
+        throw err;
       }
 
-      // Calculate delay and wait before retrying
       const delay = calculateBackoffDelay(
         attempt,
         retryConfig.baseDelay,
         retryConfig.maxDelay,
       );
 
-      // Notify callback if provided
       if (onRetry) {
-        onRetry(attempt + 1, delay, axiosError);
+        onRetry(attempt + 1, delay, err);
       }
 
       await sleep(delay);
     }
   }
 
-  // This should never be reached, but TypeScript needs it
+  // Unreachable — the loop always returns or throws before exhausting attempts.
   throw lastError;
 }

package/src/api/stores/auth-store.ts

@@ -1,17 +1,40 @@
 import { create } from 'zustand';
 
 /**
- * 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 const useAuthStore = create<AuthState>((set) => ({
   token: null,

package/src/api/types.ts

@@ -1,74 +1,114 @@
-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>;
+}
+
+/**
+ * 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';
 }
 
 /**
- * Interface for HTTP client adapter
- * Defines the contract all HTTP adapters must implement
+ * 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,
+    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,
+    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[];
 }

package/src/api.tsx

@@ -13,5 +13,5 @@ export {
   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';

package/src/components/Carousel/components/see-all-button.tsx

@@ -5,17 +5,19 @@ import { Text } from '../../Text';
 import { SeeAllButton } from '../styles';
 
 type CarouselSeeAllButtonProps = {
+  text?: string;
   color?: string;
 } & TouchableOpacityProps;
 
 const CarouselSeeAllButton = ({
   color,
+  text = 'Ver todos',
   ...props
 }: CarouselSeeAllButtonProps) => {
   return (
     <SeeAllButton {...props}>
       <Text weight="bold" color={color ?? '#014661'}>
-        Ver todos
+        {text}
       </Text>
       <FontAwesomeIcon
         icon={faChevronRight}

package/src/components/Carousel/index.tsx

@@ -34,7 +34,7 @@ const CarouselRoot = <T,>({
 
   const listRef = useRef<FlatList<T> | null>(null);
   const activeIndexRef = useRef(defaultIndex ?? 0);
-  const autoPlayTimerRef = useRef<NodeJS.Timeout | null>(null);
+  const autoPlayTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const isUserInteracting = useRef(false);
 
   const [activeIndex, setActiveIndex] = useState(() => defaultIndex ?? 0);

package/src/index.tsx

@@ -21,9 +21,9 @@ export {
   ValidationError,
 } from './api/errors';
 
-export { AxiosAdapter, apiRequest, useAuthStore } from './api/index';
+export { apiRequest, NitroAdapter, useAuthStore } from './api/index';
 
-export type { ApiConfig, IHttpAdapter } from './api/types';
+export type { ApiConfig, IHttpAdapter, RequestConfig } from './api/types';
 export type { ButtonProps } from './components/Button';
 // Components
 export { Button } from './components/Button';

package/lib/module/api/axios-adapter.js

@@ -1,154 +0,0 @@
-"use strict";
-
-import axios from 'axios';
-import { AuthError, NetworkError, NotFoundError, RateLimitError, ServerError, TimeoutError, ValidationError } from "./errors.js";
-import { executeWithRetry } from "./retry-strategy.js";
-import { useAuthStore } from "./stores/auth-store.js";
-/**
- * Axios-based HTTP adapter implementation
- * Implements retry logic, error handling, and token management
- */
-export class AxiosAdapter {
-  constructor(config) {
-    // Initialize axios instance with configuration
-    this.axiosInstance = axios.create({
-      baseURL: config.baseURL,
-      timeout: config.timeout ?? 30000,
-      // 30 seconds default
-      headers: {
-        'Content-Type': 'application/json',
-        ...config.headers
-      }
-    });
-
-    // Configure retry behavior
-    this.retryConfig = {
-      maxAttempts: config.retryAttempts ?? 3,
-      baseDelay: 1000,
-      // 1 second
-      maxDelay: 10000,
-      // 10 seconds
-      retryableStatusCodes: [408, 429, 500, 502, 503, 504]
-    };
-
-    // Setup request interceptor to inject auth token
-    this.setupRequestInterceptor();
-  }
-
-  /**
-   * Sets up request interceptor to automatically add auth token
-   */
-  setupRequestInterceptor() {
-    this.axiosInstance.interceptors.request.use(config => {
-      const token = useAuthStore.getState().token;
-      if (token && config.headers) {
-        config.headers.Authorization = `Bearer ${token}`;
-      }
-      return config;
-    }, error => Promise.reject(error));
-  }
-
-  /**
-   * Maps axios error to appropriate custom error type
-   */
-  mapError(error, url, method) {
-    // Network errors (no response received)
-    if (!error.response) {
-      if (error.code === 'ECONNABORTED' || error.message.includes('timeout')) {
-        return new TimeoutError('Request timeout - server took too long to respond', url, method);
-      }
-      return new NetworkError(error.message || 'Network error - please check your connection', url, method);
-    }
-    const statusCode = error.response.status;
-    const responseData = error.response.data;
-    const message = responseData?.message || error.message || 'An error occurred';
-
-    // Map status codes to error types
-    switch (true) {
-      case statusCode === 401 || statusCode === 403:
-        return new AuthError(message, statusCode, url, method);
-      case statusCode === 404:
-        return new NotFoundError(message, url, method);
-      case statusCode === 429:
-        return new RateLimitError(message, url, method, Number(error.response.headers['retry-after']));
-      case statusCode === 400 || statusCode === 422:
-        return new ValidationError(message, statusCode, url, method, responseData?.errors);
-      case statusCode >= 500:
-        return new ServerError(message, statusCode, url, method);
-      default:
-        return new NetworkError(message, url, method);
-    }
-  }
-
-  /**
-   * Transforms axios response to standardized ApiResponse format
-   */
-  transformResponse(response) {
-    return response.data;
-  }
-
-  /**
-   * Executes HTTP request with retry logic and error handling
-   */
-  async executeRequest(requestFn, url, method) {
-    try {
-      const response = await executeWithRetry(requestFn, this.retryConfig, (attempt, delay, error) => {
-        console.log(`[API Retry] Attempt ${attempt} failed, retrying in ${delay}ms...`, error.message);
-      });
-      return this.transformResponse(response);
-    } catch (error) {
-      throw this.mapError(error, url, method);
-    }
-  }
-
-  /**
-   * Performs GET request
-   */
-  async get(url, config) {
-    return this.executeRequest(() => this.axiosInstance.get(url, config), url, 'GET');
-  }
-
-  /**
-   * Performs POST request
-   */
-  async post(url, data, config) {
-    return this.executeRequest(() => this.axiosInstance.post(url, data, config), url, 'POST');
-  }
-
-  /**
-   * Performs PUT request
-   */
-  async put(url, data, config) {
-    return this.executeRequest(() => this.axiosInstance.put(url, data, config), url, 'PUT');
-  }
-
-  /**
-   * Performs DELETE request
-   */
-  async delete(url, config) {
-    return this.executeRequest(() => this.axiosInstance.delete(url, config), url, 'DELETE');
-  }
-
-  /**
-   * Adds authentication token to store
-   * Token will be automatically included in all subsequent requests
-   */
-  addToken(token) {
-    useAuthStore.getState().setToken(token);
-  }
-
-  /**
-   * Removes authentication token from store
-   */
-  removeToken() {
-    useAuthStore.getState().clearToken();
-  }
-
-  /**
-   * Get token from store
-   */
-  getToken() {
-    return useAuthStore.getState().token;
-  }
-}
-//# sourceMappingURL=axios-adapter.js.map

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

@@ -1,57 +0,0 @@
-import { type AxiosRequestConfig } from 'axios';
-import type { ApiConfig, IHttpAdapter } from './types';
-/**
- * Axios-based HTTP adapter implementation
- * Implements retry logic, error handling, and token management
- */
-export declare class AxiosAdapter implements IHttpAdapter {
-    private readonly axiosInstance;
-    private readonly retryConfig;
-    constructor(config: ApiConfig);
-    /**
-     * Sets up request interceptor to automatically add auth token
-     */
-    private setupRequestInterceptor;
-    /**
-     * Maps axios error to appropriate custom error type
-     */
-    private mapError;
-    /**
-     * Transforms axios response to standardized ApiResponse format
-     */
-    private transformResponse;
-    /**
-     * Executes HTTP request with retry logic and error handling
-     */
-    private executeRequest;
-    /**
-     * Performs GET request
-     */
-    get<T = unknown>(url: string, config?: AxiosRequestConfig): Promise<T>;
-    /**
-     * Performs POST request
-     */
-    post<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T>;
-    /**
-     * Performs PUT request
-     */
-    put<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T>;
-    /**
-     * Performs DELETE request
-     */
-    delete<T = unknown>(url: string, config?: AxiosRequestConfig): Promise<T>;
-    /**
-     * Adds authentication token to store
-     * Token will be automatically included in all subsequent requests
-     */
-    addToken(token: string): void;
-    /**
-     * Removes authentication token from store
-     */
-    removeToken(): void;
-    /**
-     * Get token from store
-     */
-    getToken(): string | null;
-}
-//# sourceMappingURL=axios-adapter.d.ts.map