@authu/react 0.1.17

package/README.md

@@ -0,0 +1,169 @@
+# @authu/react
+
+React SDK for AuthU - Centralized Multi-Tenant Authentication Service.
+
+## Installation
+
+```sh
+npm install @authu/react
+# or
+pnpm add @authu/react
+# or
+yarn add @authu/react
+```
+
+## Usage
+
+### 1. Configure the Provider
+
+Wrap your app with `AuthUProvider`:
+
+```tsx
+import {AuthUProvider} from '@authu/react';
+
+function App() {
+  return (
+    <AuthUProvider
+      domain="https://auth.example.com"
+      clientId="your-client-id"
+      redirectUri={window.location.origin + '/callback'}
+    >
+      <YourApp />
+    </AuthUProvider>
+  );
+}
+```
+
+### 2. Use the Hook
+
+Access authentication state and methods with `useAuthU`:
+
+```tsx
+import {useAuthU} from '@authu/react';
+
+function Profile() {
+  const {isAuthenticated, isLoading, user, login, logout} = useAuthU();
+
+  if (isLoading) return <div>Loading...</div>;
+
+  if (!isAuthenticated) {
+    return <button onClick={() => login()}>Log in</button>;
+  }
+
+  return (
+    <div>
+      <p>Welcome, {user?.name}</p>
+      <button onClick={() => logout()}>Log out</button>
+    </div>
+  );
+}
+```
+
+### 3. Protect Routes
+
+Use `PrivateRoute` to protect authenticated routes:
+
+```tsx
+import {PrivateRoute} from '@authu/react';
+
+function AppRoutes() {
+  return (
+    <Routes>
+      <Route path="/" element={<Home />} />
+      <Route
+        path="/dashboard"
+        element={
+          <PrivateRoute>
+            <Dashboard />
+          </PrivateRoute>
+        }
+      />
+    </Routes>
+  );
+}
+```
+
+### 4. Get Access Token for API Calls
+
+Use `useApiToken` to get tokens for authenticated API requests:
+
+```tsx
+import {useApiToken} from '@authu/react';
+
+function ApiComponent() {
+  const {getToken} = useApiToken();
+
+  const fetchData = async () => {
+    const token = await getToken();
+    const response = await fetch('/api/data', {
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    });
+    return response.json();
+  };
+
+  return <button onClick={fetchData}>Fetch Data</button>;
+}
+```
+
+## API Reference
+
+### AuthUProvider Props
+
+| Prop | Type | Required | Description |
+|------|------|----------|-------------|
+| `domain` | `string` | Yes | AuthU server URL |
+| `clientId` | `string` | Yes | OAuth2 client ID |
+| `redirectUri` | `string` | Yes | Callback URL after login |
+| `scope` | `string` | No | OAuth2 scopes (default: `openid profile email`) |
+| `audience` | `string` | No | API audience for access tokens |
+
+### useAuthU Returns
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `isLoading` | `boolean` | True while checking auth state |
+| `isAuthenticated` | `boolean` | True if user is logged in |
+| `user` | `AuthUUser \| null` | User profile info |
+| `error` | `Error \| null` | Auth error if any |
+| `login(options?)` | `function` | Redirect to login |
+| `logout(options?)` | `function` | Log out user |
+| `getAccessToken()` | `function` | Get current access token |
+
+## Development
+
+### Build
+
+```sh
+pnpm run build
+```
+
+### Lint
+
+```sh
+pnpm run lint
+```
+
+## Publishing
+
+### Prerequisites
+
+- Be logged in to npm: `npm login`
+- Have publish rights on `@authu` scope
+
+### Publish a New Version
+
+1. Update version in `package.json`
+2. Build and publish:
+
+```sh
+pnpm run build
+pnpm publish --access public
+```
+
+The `--access public` flag is required for scoped packages.
+
+## License
+
+MIT

package/dist/AuthUProvider.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from 'react';
+import type { AuthUConfig, AuthUContextValue } from './types.js';
+export declare const AuthUContext: import("react").Context<AuthUContextValue | null>;
+interface AuthUProviderProps {
+    config: AuthUConfig;
+    children: ReactNode;
+}
+export declare function AuthUProvider({ config, children }: AuthUProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=AuthUProvider.d.ts.map

package/dist/AuthUProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthUProvider.d.ts","sourceRoot":"","sources":["../src/AuthUProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,KAAK,EACV,WAAW,EACX,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AAgBpB,eAAO,MAAM,YAAY,mDAAgD,CAAC;AAE1E,UAAU,kBAAkB;IAC1B,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAID,wBAAgB,aAAa,CAAC,EAAC,MAAM,EAAE,QAAQ,EAAC,EAAE,kBAAkB,2CAySnE"}

package/dist/AuthUProvider.js

@@ -0,0 +1,250 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useEffect, useState, useCallback } from 'react';
+import { generateCodeVerifier, generateCodeChallenge, generateState, generateNonce, storeCodeVerifier, storeState, storeNonce, getCodeVerifier, getStoredState, clearCodeVerifier, clearState, clearNonce } from './pkce.js';
+export const AuthUContext = createContext(null);
+const TOKEN_STORAGE_KEY = 'authu_tokens';
+export function AuthUProvider({ config, children }) {
+    const [state, setState] = useState({
+        isLoading: true,
+        isAuthenticated: false,
+        user: null,
+        accessToken: null,
+        refreshToken: null,
+        expiresAt: null,
+        error: null
+    });
+    const getAuthorizationUrl = useCallback(async () => {
+        const codeVerifier = generateCodeVerifier();
+        const codeChallenge = await generateCodeChallenge(codeVerifier);
+        const stateValue = generateState();
+        const nonceValue = generateNonce();
+        storeCodeVerifier(codeVerifier);
+        storeState(stateValue);
+        storeNonce(nonceValue);
+        const params = new URLSearchParams({
+            client_id: config.clientId,
+            redirect_uri: config.redirectUri,
+            response_type: 'code',
+            scope: config.scope || 'openid profile email',
+            state: stateValue,
+            nonce: nonceValue,
+            code_challenge: codeChallenge,
+            code_challenge_method: 'S256'
+        });
+        return `https://${config.domain}/authorize?${params.toString()}`;
+    }, [config]);
+    const exchangeCodeForTokens = useCallback(async (code) => {
+        const codeVerifier = getCodeVerifier();
+        if (!codeVerifier) {
+            throw new Error('No code verifier found');
+        }
+        const response = await fetch(`https://${config.domain}/oauth/token`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                grant_type: 'authorization_code',
+                code,
+                redirect_uri: config.redirectUri,
+                client_id: config.clientId,
+                code_verifier: codeVerifier
+            })
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(error.error_description || 'Token exchange failed');
+        }
+        const tokens = await response.json();
+        clearCodeVerifier();
+        clearState();
+        clearNonce();
+        return tokens;
+    }, [config]);
+    const parseIdToken = (idToken) => {
+        const parts = idToken.split('.');
+        if (parts.length !== 3) {
+            throw new Error('Invalid ID token');
+        }
+        const payload = JSON.parse(atob(parts[1]));
+        return {
+            sub: payload.sub,
+            email: payload.email,
+            emailVerified: payload.email_verified,
+            name: payload.name,
+            picture: payload.picture
+        };
+    };
+    const login = useCallback(async () => {
+        const url = await getAuthorizationUrl();
+        window.location.href = url;
+    }, [getAuthorizationUrl]);
+    const logout = useCallback(() => {
+        localStorage.removeItem(TOKEN_STORAGE_KEY);
+        setState({
+            isLoading: false,
+            isAuthenticated: false,
+            user: null,
+            accessToken: null,
+            refreshToken: null,
+            expiresAt: null,
+            error: null
+        });
+    }, []);
+    const fetchUserInfo = useCallback(async (accessToken) => {
+        try {
+            const response = await fetch(`https://${config.domain}/oauth/userinfo`, {
+                headers: { Authorization: `Bearer ${accessToken}` }
+            });
+            if (!response.ok)
+                return null;
+            const userInfo = await response.json();
+            return {
+                sub: userInfo.sub,
+                email: userInfo.email,
+                emailVerified: userInfo.email_verified,
+                name: userInfo.name,
+                picture: userInfo.picture
+            };
+        }
+        catch {
+            return null;
+        }
+    }, [config.domain]);
+    const refreshTokens = useCallback(async () => {
+        if (!state.refreshToken)
+            return false;
+        try {
+            const response = await fetch(`https://${config.domain}/oauth/token`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    grant_type: 'refresh_token',
+                    refresh_token: state.refreshToken,
+                    client_id: config.clientId
+                })
+            });
+            if (!response.ok) {
+                logout();
+                return false;
+            }
+            const tokens = await response.json();
+            const expiresAt = Date.now() + tokens.expires_in * 1000;
+            const user = tokens.id_token ? parseIdToken(tokens.id_token) : state.user;
+            localStorage.setItem(TOKEN_STORAGE_KEY, JSON.stringify({
+                accessToken: tokens.access_token,
+                refreshToken: tokens.refresh_token,
+                expiresAt
+            }));
+            setState(prev => ({
+                ...prev,
+                accessToken: tokens.access_token,
+                refreshToken: tokens.refresh_token,
+                expiresAt,
+                user: user || prev.user
+            }));
+            return true;
+        }
+        catch {
+            logout();
+            return false;
+        }
+    }, [state.refreshToken, state.user, config.domain, config.clientId, logout]);
+    const getAccessToken = useCallback(async () => {
+        if (!state.accessToken)
+            return null;
+        if (state.expiresAt && Date.now() >= state.expiresAt - 60000) {
+            const refreshed = await refreshTokens();
+            if (!refreshed)
+                return null;
+        }
+        return state.accessToken;
+    }, [state.accessToken, state.expiresAt, refreshTokens]);
+    useEffect(() => {
+        const handleCallback = async () => {
+            const params = new URLSearchParams(window.location.search);
+            const code = params.get('code');
+            const returnedState = params.get('state');
+            const error = params.get('error');
+            if (error) {
+                setState(prev => ({
+                    ...prev,
+                    isLoading: false,
+                    error: new Error(params.get('error_description') || error)
+                }));
+                return;
+            }
+            if (code) {
+                const storedState = getStoredState();
+                if (returnedState !== storedState) {
+                    setState(prev => ({
+                        ...prev,
+                        isLoading: false,
+                        error: new Error('Invalid state parameter')
+                    }));
+                    return;
+                }
+                try {
+                    const tokens = await exchangeCodeForTokens(code);
+                    const user = parseIdToken(tokens.id_token);
+                    const expiresAt = Date.now() + tokens.expires_in * 1000;
+                    localStorage.setItem(TOKEN_STORAGE_KEY, JSON.stringify({
+                        accessToken: tokens.access_token,
+                        refreshToken: tokens.refresh_token,
+                        expiresAt
+                    }));
+                    setState({
+                        isLoading: false,
+                        isAuthenticated: true,
+                        user,
+                        accessToken: tokens.access_token,
+                        refreshToken: tokens.refresh_token,
+                        expiresAt,
+                        error: null
+                    });
+                    window.history.replaceState({}, document.title, window.location.pathname);
+                }
+                catch (err) {
+                    setState(prev => ({
+                        ...prev,
+                        isLoading: false,
+                        error: err instanceof Error ? err : new Error('Authentication failed')
+                    }));
+                }
+                return;
+            }
+            const stored = localStorage.getItem(TOKEN_STORAGE_KEY);
+            if (stored) {
+                try {
+                    const tokens = JSON.parse(stored);
+                    if (tokens.expiresAt > Date.now()) {
+                        const user = await fetchUserInfo(tokens.accessToken);
+                        setState({
+                            isLoading: false,
+                            isAuthenticated: true,
+                            user,
+                            accessToken: tokens.accessToken,
+                            refreshToken: tokens.refreshToken,
+                            expiresAt: tokens.expiresAt,
+                            error: null
+                        });
+                        return;
+                    }
+                }
+                catch {
+                    localStorage.removeItem(TOKEN_STORAGE_KEY);
+                }
+            }
+            setState(prev => ({ ...prev, isLoading: false }));
+        };
+        handleCallback();
+    }, [exchangeCodeForTokens, fetchUserInfo]);
+    const contextValue = {
+        isLoading: state.isLoading,
+        isAuthenticated: state.isAuthenticated,
+        user: state.user,
+        error: state.error,
+        login,
+        logout,
+        getAccessToken
+    };
+    return (_jsx(AuthUContext.Provider, { value: contextValue, children: children }));
+}

package/dist/PrivateRoute.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+interface PrivateRouteProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+    loginOnUnauthenticated?: boolean;
+}
+export declare function PrivateRoute({ children, fallback, loginOnUnauthenticated }: PrivateRouteProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=PrivateRoute.d.ts.map

package/dist/PrivateRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrivateRoute.d.ts","sourceRoot":"","sources":["../src/PrivateRoute.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,OAAO,CAAC;AAGrC,UAAU,iBAAiB;IACzB,QAAQ,EAAE,SAAS,CAAC;IACpB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,QAAe,EACf,sBAA6B,EAC9B,EAAE,iBAAiB,+TAenB"}

package/dist/PrivateRoute.js

@@ -0,0 +1,15 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useAuthU } from './useAuthU.js';
+export function PrivateRoute({ children, fallback = null, loginOnUnauthenticated = true }) {
+    const { isLoading, isAuthenticated, login } = useAuthU();
+    if (isLoading) {
+        return fallback;
+    }
+    if (!isAuthenticated) {
+        if (loginOnUnauthenticated) {
+            login();
+        }
+        return fallback;
+    }
+    return _jsx(_Fragment, { children: children });
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { AuthUProvider } from './AuthUProvider.js';
+export { useAuthU } from './useAuthU.js';
+export { useApiToken } from './useApiToken.js';
+export { PrivateRoute } from './PrivateRoute.js';
+export * from './pkce.js';
+export type { AuthUConfig, AuthUUser, AuthUContextValue } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAC,QAAQ,EAAC,MAAM,eAAe,CAAC;AACvC,OAAO,EAAC,WAAW,EAAC,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAC,YAAY,EAAC,MAAM,mBAAmB,CAAC;AAC/C,cAAc,WAAW,CAAC;AAC1B,YAAY,EAAC,WAAW,EAAE,SAAS,EAAE,iBAAiB,EAAC,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { AuthUProvider } from './AuthUProvider.js';
+export { useAuthU } from './useAuthU.js';
+export { useApiToken } from './useApiToken.js';
+export { PrivateRoute } from './PrivateRoute.js';
+export * from './pkce.js';

package/dist/pkce.d.ts

@@ -0,0 +1,14 @@
+export declare function generateCodeVerifier(): string;
+export declare function generateCodeChallenge(verifier: string): Promise<string>;
+export declare function generateState(): string;
+export declare function generateNonce(): string;
+export declare function storeCodeVerifier(verifier: string): void;
+export declare function getCodeVerifier(): string | null;
+export declare function clearCodeVerifier(): void;
+export declare function storeState(state: string): void;
+export declare function getStoredState(): string | null;
+export declare function clearState(): void;
+export declare function storeNonce(nonce: string): void;
+export declare function getStoredNonce(): string | null;
+export declare function clearNonce(): void;
+//# sourceMappingURL=pkce.d.ts.map

package/dist/pkce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pkce.d.ts","sourceRoot":"","sources":["../src/pkce.ts"],"names":[],"mappings":"AA2BA,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C;AAED,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAG7E;AAED,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAMD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAExD;AAED,wBAAgB,eAAe,IAAI,MAAM,GAAG,IAAI,CAE/C;AAED,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE9C;AAED,wBAAgB,cAAc,IAAI,MAAM,GAAG,IAAI,CAE9C;AAED,wBAAgB,UAAU,IAAI,IAAI,CAEjC;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE9C;AAED,wBAAgB,cAAc,IAAI,MAAM,GAAG,IAAI,CAE9C;AAED,wBAAgB,UAAU,IAAI,IAAI,CAEjC"}

package/dist/pkce.js

@@ -0,0 +1,66 @@
+function generateRandomString(length) {
+    const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~';
+    const randomValues = crypto.getRandomValues(new Uint8Array(length));
+    return Array.from(randomValues)
+        .map(v => charset[v % charset.length])
+        .join('');
+}
+async function sha256(plain) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(plain);
+    return crypto.subtle.digest('SHA-256', data);
+}
+function base64UrlEncode(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let binary = '';
+    for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary)
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/, '');
+}
+export function generateCodeVerifier() {
+    return generateRandomString(64);
+}
+export async function generateCodeChallenge(verifier) {
+    const hash = await sha256(verifier);
+    return base64UrlEncode(hash);
+}
+export function generateState() {
+    return generateRandomString(32);
+}
+export function generateNonce() {
+    return generateRandomString(32);
+}
+const STORAGE_KEY_VERIFIER = 'authu_code_verifier';
+const STORAGE_KEY_STATE = 'authu_state';
+const STORAGE_KEY_NONCE = 'authu_nonce';
+export function storeCodeVerifier(verifier) {
+    sessionStorage.setItem(STORAGE_KEY_VERIFIER, verifier);
+}
+export function getCodeVerifier() {
+    return sessionStorage.getItem(STORAGE_KEY_VERIFIER);
+}
+export function clearCodeVerifier() {
+    sessionStorage.removeItem(STORAGE_KEY_VERIFIER);
+}
+export function storeState(state) {
+    sessionStorage.setItem(STORAGE_KEY_STATE, state);
+}
+export function getStoredState() {
+    return sessionStorage.getItem(STORAGE_KEY_STATE);
+}
+export function clearState() {
+    sessionStorage.removeItem(STORAGE_KEY_STATE);
+}
+export function storeNonce(nonce) {
+    sessionStorage.setItem(STORAGE_KEY_NONCE, nonce);
+}
+export function getStoredNonce() {
+    return sessionStorage.getItem(STORAGE_KEY_NONCE);
+}
+export function clearNonce() {
+    sessionStorage.removeItem(STORAGE_KEY_NONCE);
+}

package/dist/types.d.ts

@@ -0,0 +1,46 @@
+export interface AuthUConfig {
+    domain: string;
+    clientId: string;
+    redirectUri: string;
+    scope?: string;
+    audience?: string;
+}
+export interface AuthUUser {
+    sub: string;
+    email?: string;
+    emailVerified?: boolean;
+    name?: string;
+    picture?: string;
+}
+export interface AuthUContextValue {
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    user: AuthUUser | null;
+    error: Error | null;
+    login: (options?: LoginOptions) => void;
+    logout: (options?: LogoutOptions) => void;
+    getAccessToken: () => Promise<string | null>;
+}
+export interface LoginOptions {
+    returnTo?: string;
+}
+export interface LogoutOptions {
+    returnTo?: string;
+}
+export interface TokenResponse {
+    accessToken: string;
+    refreshToken?: string;
+    idToken?: string;
+    expiresIn: number;
+    tokenType: string;
+}
+export interface AuthState {
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    user: AuthUUser | null;
+    accessToken: string | null;
+    refreshToken: string | null;
+    expiresAt: number | null;
+    error: Error | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,KAAK,EAAE,CAAC,OAAO,CAAC,EAAE,YAAY,KAAK,IAAI,CAAC;IACxC,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;IAC1C,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IACvB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/useApiToken.d.ts

@@ -0,0 +1,7 @@
+interface UseApiTokenReturn {
+    getToken: () => Promise<string | null>;
+    fetchWithToken: (url: string, options?: RequestInit) => Promise<Response>;
+}
+export declare function useApiToken(): UseApiTokenReturn;
+export {};
+//# sourceMappingURL=useApiToken.d.ts.map

package/dist/useApiToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useApiToken.d.ts","sourceRoot":"","sources":["../src/useApiToken.ts"],"names":[],"mappings":"AAGA,UAAU,iBAAiB;IACzB,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACvC,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC3E;AAED,wBAAgB,WAAW,IAAI,iBAAiB,CA4B/C"}

package/dist/useApiToken.js

@@ -0,0 +1,23 @@
+import { useCallback } from 'react';
+import { useAuthU } from './useAuthU.js';
+export function useApiToken() {
+    const { getAccessToken, isAuthenticated } = useAuthU();
+    const getToken = useCallback(async () => {
+        if (!isAuthenticated) {
+            return null;
+        }
+        return getAccessToken();
+    }, [isAuthenticated, getAccessToken]);
+    const fetchWithToken = useCallback(async (url, options = {}) => {
+        const token = await getToken();
+        const headers = new Headers(options.headers);
+        if (token) {
+            headers.set('Authorization', `Bearer ${token}`);
+        }
+        return fetch(url, {
+            ...options,
+            headers
+        });
+    }, [getToken]);
+    return { getToken, fetchWithToken };
+}

package/dist/useAuthU.d.ts

@@ -0,0 +1,3 @@
+import type { AuthUContextValue } from './types.js';
+export declare function useAuthU(): AuthUContextValue;
+//# sourceMappingURL=useAuthU.d.ts.map

package/dist/useAuthU.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuthU.d.ts","sourceRoot":"","sources":["../src/useAuthU.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,YAAY,CAAC;AAElD,wBAAgB,QAAQ,IAAI,iBAAiB,CAQ5C"}

package/dist/useAuthU.js

@@ -0,0 +1,9 @@
+import { useContext } from 'react';
+import { AuthUContext } from './AuthUProvider.js';
+export function useAuthU() {
+    const context = useContext(AuthUContext);
+    if (!context) {
+        throw new Error('useAuthU must be used within an AuthUProvider');
+    }
+    return context;
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@authu/react",
+  "version": "0.1.17",
+  "description": "React SDK for AuthU - Centralized Multi-Tenant Authentication Service",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "authu",
+    "auth",
+    "authentication",
+    "oauth2",
+    "oidc",
+    "react",
+    "hooks"
+  ],
+  "author": "Uralys",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.36.0",
+    "@types/react": "^19.0.4",
+    "eslint": "^9.36.0",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "prettier": "^3.6.2",
+    "react": "^19.0.0",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.44.1"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "eslint": "eslint src --cache",
+    "typecheck": "tsc --noEmit",
+    "lint": "pnpm run eslint && pnpm run typecheck"
+  }
+}