@forgepack/request 1.0.5 → 1.0.7

package/README.md

@@ -1,90 +1,85 @@
-# _Request_
+<div align="center">
+<h1> @forgepack/request </h1>
+</div>
+
+**Production-ready HTTP client with JWT authentication for React**
 
+[![npm version](https://img.shields.io/npm/v/@forgepack/request?color=blue)](https://www.npmjs.com/package/@forgepack/request)
+[![npm downloads](https://img.shields.io/npm/dm/@forgepack/request)](https://www.npmjs.com/package/@forgepack/request)
 [![GitHub stars](https://img.shields.io/github/stars/forgepack/request?style=social)](https://github.com/forgepack/request)
-	
-![Node.js](https://img.shields.io/badge/Node.js-22.20.0-339933?logo=node.js)
-![npm](https://img.shields.io/badge/npm-11.6.2-CB3837?logo=npm)
-![React](https://img.shields.io/badge/React-19.2.0-blue?logo=react)
-![TypeScript](https://img.shields.io/badge/TypeScript-5.9.3-blue?logo=typescript)
+[![license](https://img.shields.io/npm/l/@forgepack/request)](https://github.com/forgepack/request/blob/main/LICENSE)
 
-## Start a new project
+[![React](https://img.shields.io/badge/React-19.2.0-61DAFB?logo=react)](https://react.dev/)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.9.3-blue?logo=typescript)](https://www.typescriptlang.org/)
+[![Axios](https://img.shields.io/badge/Axios-Latest-5A29E4?logo=axios)](https://axios-http.com/)
 
-```bash
-mkdir package-name
-cd package-name
-npm init
-```
+[Documentation](https://forgepack.dev/packages/request) • [NPM Package](https://www.npmjs.com/package/@forgepack/request) • [GitHub](https://github.com/forgepack/request) • [Report Bug](https://github.com/forgepack/request/issues)
 
-> .json file created:
-```json
-{
-  "name": "package-name",
-  "version": "1.0.0",
-  "description": "Package Description",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": ["palavra-chave1", "palavra-chave2"],
-  "author": "Name",
-  "license": "MIT"
-}
-```
+## Summary
 
-## Publicar no _npm_
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Using CRUD Operations](#using-crud-operations)
+- [Route Protection](#route-protection)
+- [When to Use](#when-to-use)
+- [Works well with](#works-well-with)
+- [Key Features](#key-features)
+- [Contributing](#contributing)
+- [Code of Conduct](#code-of-conduct)
+- [Author and Developers](#author-and-developers)
+- [License](#license)
 
-```bash
-# Login no npm
-npm login
-# Constrói
-npm run build
-# Simula publicação
-npm pack
-# Publicar o pacote, na primeira vez
-npm publish --access public
-```
+## Description
 
-## Atualizar versões
-> Quando fizer mudanças:
-```bash
-npm version patch  # 1.0.0 -> 1.0.1
-npm version minor  # 1.0.0 -> 1.1.0
-npm version major  # 1.0.0 -> 2.0.0
+`@forgepack/request` is a complete, opinionated HTTP client built on top of Axios for React applications. It provides automatic JWT authentication, request/response interceptors, React hooks for state management, and standardized CRUD operations—everything you need to handle API communication in modern React apps.
 
-npm publish
-```
+**Perfect for:** Teams building React applications with JWT-based backends who want a plug-and-play solution that handles authentication, authorization, and API requests with minimal boilerplate.
+
+# Consumer use
 
-## Publish at
+## Installation
 ```bash
-https://github.com/forgepack
-https://www.npmjs.com/org/forgepack
-https://dev.to/
-https://codesandbox.io/
-https://stackblitz.com/
-```
+# npm
+npm install @forgepack/request
 
-## Uso pelo consumidor (Vite, React, Next, Node, etc.)
+# yarn
+yarn add @forgepack/request
 
-### 📦 **Instalação**
+# pnpm
+pnpm add @forgepack/request
+```
 
-```bash
-npm install @forgepack/request
+### Peer Dependencies
+
+Make sure you have these installed:
+```json
+{
+  "react": ">=16.8.0",
+  "react-dom": ">=16.8.0",
+  "axios": ">=1.0.0",
+  "react-router-dom": ">=6.0.0" // Optional, only if using RequireAuth
+}
 ```
 
-### ⚙️ **Configuração Básica**
+## Quick Start
 
+### Configure the API client
 ```typescript
-// 1. Configure o cliente da API
 import { createApiClient } from "@forgepack/request"
 
 export const api = createApiClient({
-  baseURL: "https://api.meuservico.com",
+  baseURL: "https://api.service.com",
+  /** Called on 401 errors */
   onUnauthorized: () => window.location.href = "/login",
+  /** Called on 403 errors */
   onForbidden: () => window.location.href = "/notAllowed"
 })
+```
 
-// 2. Configure o provedor de autenticação
+### Configure the authentication provider
+```typescript
 import { AuthProvider } from '@forgepack/request'
+import { api } from './api/client'
 
 function App() {
   return (
@@ -95,43 +90,175 @@ function App() {
 }
 ```
 
-### 🚀 **Principais Recursos**
+### Use in Components
+```typescript
+import { useAuth } from '@forgepack/request'
+import { useNavigate } from 'react-router-dom'
+
+function LoginPage() {
+  const { loginUser } = useAuth()
+  const navigate = useNavigate()
+
+  const handleLogin = async (credentials) => {
+    const result = await loginUser(credentials)
+    
+    if (result.success) {
+      navigate('/dashboard')
+    } else {
+      console.error('Login failed:', result.errors)
+    }
+  }
+
+  return (
+    <div>
+      {/* Your login form here */}
+    </div>
+  )
+}
+```
+
+## Using CRUD Operations
+```typescript
+import { create, retrieve, update, remove } from '@forgepack/request'
+import { api } from './api/client'
+
+// Create
+const newUser = await create(api, 'users', {
+  name: 'John Snow',
+  email: 'john@example.com'
+})
+
+// Retrieve all
+const allUsers = await retrieve(api, 'users')
+
+// Retrieve paginated
+const page = await retrieve(api, 'users', { page: 0, size: 10 })
+
+// Update
+const updated = await update(api, 'users', {
+  id: 1,
+  name: 'John Smith'
+})
+
+// Delete
+await remove(api, 'users', '1')
+```
+
+## Route Protection
+```typescript
+import { RequireAuth } from '@forgepack/request'
+import { Route, Routes } from 'react-router-dom'
+
+function App() {
+  return (
+    <Routes>
+      {/* Public routes */}
+      <Route path="/login" element={<LoginPage />} />
+      
+      {/* Protected routes - any authenticated user */}
+      <Route path="/dashboard" element={<RequireAuth allowedRoles={['USER', 'ADMIN']}><Dashboard /></RequireAuth>} />
+      
+      {/* Admin-only routes */}
+      <Route path="/admin" element={<RequireAuth allowedRoles={['ADMIN']}><AdminPanel /></RequireAuth>} />
+    </Routes>
+  )
+}
+```
+
+### Token Management
+```typescript
+import { getToken, getPayload, isValidToken } from '@forgepack/request'
+
+/** Check if token is valid */
+if (isValidToken()) {
+  console.log('User is authenticated')
+}
+
+/** Get token data */
+const auth = getToken()
+console.log(auth.accessToken)
+console.log(auth.role)
+
+/** Decode payload */
+const payload = getPayload()
+console.log('User ID:', payload.sub)
+console.log('Expires at:', new Date(payload.exp * 1000))
+```
+
+## When to Use
+
+### Perfect for:
+- ✅ React applications (16.8+)
+- ✅ JWT-based authentication
+- ✅ RESTful APIs
+- ✅ Applications requiring role-based access control
+- ✅ Projects that need standardized CRUD operations
+- ✅ Teams wanting to reduce authentication boilerplate
+
+### Use not recommended when:
+- ❌ GraphQL APIs (use Apollo Client instead)
+- ❌ Non-JWT authentication (OAuth2, session-based, etc.)
+- ❌ Server-side rendering with Next.js (token management relies on localStorage)
+- ❌ React Native (localStorage not available)
 
-- **🔐 Autenticação JWT** - Login automático com interceptors
-- **🛡️ Proteção de Rotas** - Componente `RequireAuth` baseado em roles
-- **📊 Hook de Requisições** - `useRequest` com paginação e busca
-- **⚡ Operações CRUD** - Funções prontas para create, read, update, delete
-- **🔑 Gerenciamento de Tokens** - Validação e decodificação automática
-- **📱 Responsivo** - Estados de loading, erro e paginação
+## Works well with
 
-### 📚 **Complete Documentation**
+Complete your React stack with other @forgepack packages:
+| Package | Description |
+|---------|-------------|
+| [@forgepack/auth-jwt](https://www.npmjs.com/package/@forgepack/auth-jwt) | Backend JWT authentication utilities |
+| [@forgepack/crud](https://www.npmjs.com/package/@forgepack/crud) | Advanced CRUD components with forms |
+| [@forgepack/layout](https://www.npmjs.com/package/@forgepack/layout) | Responsive layout components |
+| [@forgepack/modal](https://www.npmjs.com/package/@forgepack/modal) | Modal dialogs for CRUD operations |
+| [@forgepack/datatable](https://www.npmjs.com/package/@forgepack/datatable) | Data tables with pagination and sorting |
+
+## Key Features
+
+- **🔐 Autenticação JWT** - Automatic login with interceptors
+- **🛡️ Route Protection** - Role-based `RequireAuth` component
+- **📊 Request Hook** - `useRequest` with pagination and search
+- **⚡ CRUD Operations** - Ready-to-use functions for create, read, update, delete.
+- **🔑 Token Management** - Automatic validation and decoding
+- **📱 Responsive** - Loading, error, and pagination states
+
+## Complete Documentation
 
 For detailed examples, usage guides, and API references, please visit:
 **[Complete Documentation](./docs/README.md)**
 
-### 🎯 **Quick Example**
+# Developer usage
 
-```tsx
-// Authentication hook
-const { loginUser, isAuthenticated, role } = useAuth()
+## Contributing
 
-// Hook for paginated requests
-const { response, loading, error } = useRequest(api, 'users', {
-  page: 0, size: 10, value: 'busca'
-})
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
 
-// Route protection
-<RequireAuth allowedRoles={['ADMIN']}>
-  <AdminPanel />
-</RequireAuth>
+### Development Setup
+```bash
+# Clone repository
+git clone https://github.com/forgepack/request.git
+cd request
+
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Build
+npm run build
 ```
 
-## Developers
-> [Gadelha TI](https://github.com/gadelhati)
+## Code of Conduct
+
+Please read our [Code of Conduct](CODE_OF_CONDUCT.md) before contributing.
+
+## Author and Developers
+- GitHub: [Gadelha TI](https://github.com/gadelhati)
+- Website: [forgepack.dev](https://forgepack.dev)
 
 ## **License**
 
-> This project is licensed under the **MIT License** - see the [MIT LICENSE]( https://choosealicense.com/licenses/mit/) file for details.
+This project is licensed under the **MIT License** - see the [MIT LICENSE]( https://choosealicense.com/licenses/mit/) file for details.
 
 ```text
 MIT License
@@ -159,6 +286,10 @@ SOFTWARE.
 
 <div align="center">
 
-Request
+**⭐ Did you like the project? Leave a star! ⭐**
+
+Made with ❤️ by the Forgepack team
+
+[Documentation](https://forgepack.dev/packages/request) • [NPM](https://www.npmjs.com/package/@forgepack/request) • [GitHub](https://github.com/forgepack/request) • [Issues](https://github.com/forgepack/request/issues)
 
-**⭐ Did you like the project? Leave a star! ⭐**
+</div>

package/dist/api/client.d.ts

@@ -1,28 +1,35 @@
 import { AxiosInstance } from "axios";
 /**
- * Opções de configuração para o cliente da API
+ * Configuration options for the API client
  * @interface ApiClientOptions
  */
 export type ApiClientOptions = {
-    /** URL base da API */
+    /** Base URL of the API (e.g., 'https://api.example.com') */
     baseURL: string;
-    /** Callback executado quando recebe erro 401 (Unauthorized) */
+    /** Callback executed when receiving 401 (Unauthorized) error - typically used to redirect to login */
     onUnauthorized?: () => void;
-    /** Callback executado quando recebe erro 403 (Forbidden) */
+    /** Callback executed when receiving 403 (Forbidden) error - typically used to show access denied message */
     onForbidden?: () => void;
 };
 /**
- * Cria uma instância configurada do cliente Axios com interceptors para autenticação JWT
+ * Creates a configured Axios client instance with interceptors for JWT authentication and error handling
  *
- * @param options - Opções de configuração do cliente
- * @returns Instância configurada do Axios com interceptors de request/response
+ * @param {ApiClientOptions} options - Client configuration options
+ * @param {string} options.baseURL - Base URL for all API requests
+ * @param {Function} [options.onUnauthorized] - Optional callback for 401 errors
+ * @param {Function} [options.onForbidden] - Optional callback for 403 errors
+ * @returns {AxiosInstance} Configured Axios instance with request/response interceptors
  *
  * @example
  * ```typescript
+ * // Basic usage
+ * const api = createApiClient({ baseURL: 'https://api.example.com' })
+ *
+ * // Usage with error handling callbacks
  * const api = createApiClient({
- *   baseURL: 'https://api.exemplo.com',
- *   onUnauthorized: () => window.location.href = '/login',
- *   onForbidden: () => alert('Acesso negado')
+ *   baseURL: 'https://api.example.com',
+ *   onUnauthorized: () => { window.location.href = '/login' },
+ *   onForbidden: () => { alert('Access denied') }
  * })
  * ```
  */

package/dist/api/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAAA,OAAc,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAG5C;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC3B,sBAAsB;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,+DAA+D;IAC/D,cAAc,CAAC,EAAE,MAAM,IAAI,CAAA;IAC3B,4DAA4D;IAC5D,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;CAC3B,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,gBAAgB,KAAG,aA4B3D,CAAA"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAAA,OAAc,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAG5C;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC3B,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAA;IACf,sGAAsG;IACtG,cAAc,CAAC,EAAE,MAAM,IAAI,CAAA;IAC3B,4GAA4G;IAC5G,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;CAC3B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,gBAAgB,KAAG,aA+B3D,CAAA"}

package/dist/api/client.js

@@ -7,25 +7,34 @@ exports.createApiClient = void 0;
 const axios_1 = __importDefault(require("axios"));
 const token_1 = require("../services/token");
 /**
- * Cria uma instância configurada do cliente Axios com interceptors para autenticação JWT
+ * Creates a configured Axios client instance with interceptors for JWT authentication and error handling
  *
- * @param options - Opções de configuração do cliente
- * @returns Instância configurada do Axios com interceptors de request/response
+ * @param {ApiClientOptions} options - Client configuration options
+ * @param {string} options.baseURL - Base URL for all API requests
+ * @param {Function} [options.onUnauthorized] - Optional callback for 401 errors
+ * @param {Function} [options.onForbidden] - Optional callback for 403 errors
+ * @returns {AxiosInstance} Configured Axios instance with request/response interceptors
  *
  * @example
  * ```typescript
+ * // Basic usage
+ * const api = createApiClient({ baseURL: 'https://api.example.com' })
+ *
+ * // Usage with error handling callbacks
  * const api = createApiClient({
- *   baseURL: 'https://api.exemplo.com',
- *   onUnauthorized: () => window.location.href = '/login',
- *   onForbidden: () => alert('Acesso negado')
+ *   baseURL: 'https://api.example.com',
+ *   onUnauthorized: () => { window.location.href = '/login' },
+ *   onForbidden: () => { alert('Access denied') }
  * })
  * ```
  */
 const createApiClient = (options) => {
+    /** Create base Axios instance with default configuration */
     const api = axios_1.default.create({
         baseURL: options.baseURL,
         headers: { 'content-type': 'application/json' }
     });
+    /** Request interceptor: Add JWT token to all requests */
     api.interceptors.request.use(async (config) => {
         var _a;
         const token = (_a = (0, token_1.getToken)()) === null || _a === void 0 ? void 0 : _a.accessToken;
@@ -34,12 +43,15 @@ const createApiClient = (options) => {
         }
         return config;
     });
+    /** Response interceptor: Handle authentication and authorization errors */
     api.interceptors.response.use((response) => response, (error) => {
         var _a, _b, _c, _d;
+        /** Handle 401 Unauthorized errors: Token invalid/expired */
         if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
             (0, token_1.removeToken)();
             (_b = options.onUnauthorized) === null || _b === void 0 ? void 0 : _b.call(options);
         }
+        /** Handle 403 Forbidden errors */
         if (((_c = error.response) === null || _c === void 0 ? void 0 : _c.status) === 403) {
             (_d = options.onForbidden) === null || _d === void 0 ? void 0 : _d.call(options);
         }

package/dist/hooks/AuthContext.d.ts

@@ -1,18 +1,18 @@
-import { Auth, LoginCredentials, LoginResponse } from '../types/auth';
+import type { Auth, LoginCredentials, LoginResponse } from '../types/auth';
 /**
- * Interface que estende Auth com métodos de autenticação
+ * Interface that extends Auth with authentication methods
  * @interface AuthContextType
  */
 export interface AuthContextType extends Auth {
-    /** Função para autenticar um usuário */
+    /** Function to authenticate a user */
     loginUser: (credentials: LoginCredentials) => Promise<LoginResponse>;
-    /** Função para desautenticar o usuário */
+    /** Function to logout the user */
     logoutUser: () => void;
-    /** Indica se o usuário está autenticado */
+    /** Indicates if the user is authenticated */
     isAuthenticated: boolean;
 }
 /**
- * Contexto React para gerenciamento de autenticação
+ * React context for authentication management
  * @constant
  */
 export declare const AuthContext: import("react").Context<AuthContextType>;

package/dist/hooks/AuthContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AuthContext.d.ts","sourceRoot":"","sources":["../../src/hooks/AuthContext.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAGrE;;;GAGG;AACH,MAAM,WAAW,eAAgB,SAAQ,IAAI;IACzC,wCAAwC;IACxC,SAAS,EAAE,CAAC,WAAW,EAAE,gBAAgB,KAAK,OAAO,CAAC,aAAa,CAAC,CAAA;IACpE,0CAA0C;IAC1C,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,2CAA2C;IAC3C,eAAe,EAAE,OAAO,CAAA;CAC3B;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,0CAAiE,CAAA"}
+{"version":3,"file":"AuthContext.d.ts","sourceRoot":"","sources":["../../src/hooks/AuthContext.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAG1E;;;GAGG;AACH,MAAM,WAAW,eAAgB,SAAQ,IAAI;IACzC,sCAAsC;IACtC,SAAS,EAAE,CAAC,WAAW,EAAE,gBAAgB,KAAK,OAAO,CAAC,aAAa,CAAC,CAAA;IACpE,kCAAkC;IAClC,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,6CAA6C;IAC7C,eAAe,EAAE,OAAO,CAAA;CAC3B;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,0CAAiE,CAAA"}

package/dist/hooks/AuthContext.js

@@ -4,7 +4,7 @@ exports.AuthContext = void 0;
 const react_1 = require("react");
 const constants_1 = require("../utils/constants");
 /**
- * Contexto React para gerenciamento de autenticação
+ * React context for authentication management
  * @constant
  */
 exports.AuthContext = (0, react_1.createContext)(constants_1.initialAuth);

package/dist/hooks/AuthProvider.d.ts

@@ -1,27 +1,44 @@
 import { AxiosInstance } from 'axios';
 /**
- * Provedor de contexto de autenticação que gerencia o estado de autenticação globalmente
+ * Properties of the AuthProvider
+ */
+export type AuthProviderProps = {
+    /** Axios instance for requests */
+    api: AxiosInstance;
+    /** Child components that will receive the context */
+    children: React.ReactNode;
+};
+/**
+ * Authentication context provider that manages authentication state globally
  *
- * Funcionalidades:
- * - Gerencia estado de autenticação persistente
- * - Verifica expiração de tokens automaticamente
- * - Sincroniza estado entre abas do navegador
- * - Fornece métodos de login/logout
+ * Features:
+ * - Manages persistent authentication state
+ * - Automatically checks token expiration
+ * - Synchronizes state between browser tabs
+ * - Provides login/logout methods
+ * - Automatically redirects to /login when token expires
  *
- * @param props - Propriedades do componente
- * @param props.api - Instância do Axios para requisições
- * @param props.children - Componentes filhos que receberão o contexto
- * @returns Provider component
+ * @param {AuthProviderProps} props - Component properties
+ * @param props.api - Axios instance for requests
+ * @param props.children - Child components that will receive the context
+ * @returns {JSX.Element} - Authentication context provider component
  *
  * @example
  * ```tsx
- * <AuthProvider api={apiClient}>
- *   <App />
- * </AuthProvider>
+ * import { createApiClient } from '@forgepack/request'
+ *
+ * const api = createApiClient({ baseURL: 'https://api.example.com' })
+ *
+ * function App() {
+ *   return (
+ *     <AuthProvider api={api}>
+ *       <Router>
+ *         <Routes />
+ *       </Router>
+ *     </AuthProvider>
+ *   )
+ * }
  * ```
  */
-export declare const AuthProvider: ({ api, children }: {
-    api: AxiosInstance;
-    children: React.ReactNode;
-}) => import("react/jsx-runtime").JSX.Element;
+export declare const AuthProvider: ({ api, children }: AuthProviderProps) => import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=AuthProvider.d.ts.map

package/dist/hooks/AuthProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AuthProvider.d.ts","sourceRoot":"","sources":["../../src/hooks/AuthProvider.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAGrC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,YAAY,GAAI,mBAAmB;IAC5C,GAAG,EAAE,aAAa,CAAA;IAClB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAC5B,4CAiDA,CAAA"}
+{"version":3,"file":"AuthProvider.d.ts","sourceRoot":"","sources":["../../src/hooks/AuthProvider.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAGrC;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC5B,kCAAkC;IAClC,GAAG,EAAE,aAAa,CAAA;IAClB,qDAAqD;IACrD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAC5B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,eAAO,MAAM,YAAY,GAAI,mBAAmB,iBAAiB,4CAiDhE,CAAA"}

package/dist/hooks/AuthProvider.js

@@ -8,24 +8,35 @@ const constants_1 = require("../utils/constants");
 const auth_1 = require("../services/auth");
 const AuthContext_1 = require("./AuthContext");
 /**
- * Provedor de contexto de autenticação que gerencia o estado de autenticação globalmente
+ * Authentication context provider that manages authentication state globally
  *
- * Funcionalidades:
- * - Gerencia estado de autenticação persistente
- * - Verifica expiração de tokens automaticamente
- * - Sincroniza estado entre abas do navegador
- * - Fornece métodos de login/logout
+ * Features:
+ * - Manages persistent authentication state
+ * - Automatically checks token expiration
+ * - Synchronizes state between browser tabs
+ * - Provides login/logout methods
+ * - Automatically redirects to /login when token expires
  *
- * @param props - Propriedades do componente
- * @param props.api - Instância do Axios para requisições
- * @param props.children - Componentes filhos que receberão o contexto
- * @returns Provider component
+ * @param {AuthProviderProps} props - Component properties
+ * @param props.api - Axios instance for requests
+ * @param props.children - Child components that will receive the context
+ * @returns {JSX.Element} - Authentication context provider component
  *
  * @example
  * ```tsx
- * <AuthProvider api={apiClient}>
- *   <App />
- * </AuthProvider>
+ * import { createApiClient } from '@forgepack/request'
+ *
+ * const api = createApiClient({ baseURL: 'https://api.example.com' })
+ *
+ * function App() {
+ *   return (
+ *     <AuthProvider api={api}>
+ *       <Router>
+ *         <Routes />
+ *       </Router>
+ *     </AuthProvider>
+ *   )
+ * }
  * ```
  */
 const AuthProvider = ({ api, children }) => {
@@ -42,7 +53,7 @@ const AuthProvider = ({ api, children }) => {
         setState(constants_1.initialAuth);
         window.location.href = '/login';
     }, []);
-    // Verifica token expirado a cada minuto
+    /** Checks for expired token every minute */
     (0, react_1.useEffect)(() => {
         const interval = setInterval(() => {
             if (state.accessToken && !(0, token_1.isValidToken)()) {
@@ -51,7 +62,7 @@ const AuthProvider = ({ api, children }) => {
         }, 60000);
         return () => clearInterval(interval);
     }, [state.accessToken, logoutUser]);
-    // Escuta mudanças no localStorage (ex.: logout em outra aba)
+    /** Listens for changes in localStorage (e.g., logout in another tab) */
     (0, react_1.useEffect)(() => {
         const handleStorageChange = (e) => {
             if (e.key === 'token') {