@shane_donnelly/dsi-internal-react-utils 0.0.2 → 0.1.1

package/README.md

@@ -1,4 +1,203 @@
-### Librairie de composants React pour les différents projet de la DSI
+# @shane_donnelly/dsi-internal-react-utils
 
-Actuellement, les composants sont des exemples. 
+Librairie de composants et utilitaires React pour les projets front-end de la DSI.
 
+## Installation
+
+```bash
+npm install @shane_donnelly/dsi-internal-react-utils keycloak-js
+```
+
+### Prérequis
+
+- Un serveur Keycloak configuré avec un realm, un client, et au moins un Identity Provider
+
+> **Recommandé** : utiliser [react-router](https://reactrouter.com/) pour éviter de perdre l'état de la page lors des redirections d'authentification.
+
+## Modules
+
+### Keycloak
+
+Wrapper de simplification pour `keycloak-js`. Gère l'authentification automatique via Identity Provider, le refresh de token, et la protection de routes/zones.
+
+[Documentation complète du module Keycloak](docs/keycloak.md)
+
+---
+
+## Exemple complet avec React Router
+
+```tsx
+// main.tsx
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import { BrowserRouter } from 'react-router-dom';
+import App from './App';
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <BrowserRouter>
+      <App />
+    </BrowserRouter>
+  </React.StrictMode>,
+);
+```
+
+```tsx
+// App.tsx
+import { Routes, Route } from 'react-router-dom';
+import { KeycloakProvider, ProtectedRoute } from '@shane_donnelly/dsi-internal-react-utils';
+import PublicPage from './pages/PublicPage';
+import Dashboard from './pages/Dashboard';
+import Profile from './pages/Profile';
+
+const keycloakConfig = {
+  url: 'https://keycloak.example.com',
+  realm: 'my-realm',
+  clientId: 'my-frontend',
+};
+
+export default function App() {
+  return (
+    <KeycloakProvider config={keycloakConfig} idpHint="oidc" refreshInterval={300}>
+      <Routes>
+        {/* Route publique — accessible sans authentification */}
+        <Route path="/" element={<PublicPage />} />
+
+        {/* Routes protégées — redirection automatique vers l'IDP */}
+        <Route
+          path="/dashboard"
+          element={
+            <ProtectedRoute>
+              <Dashboard />
+            </ProtectedRoute>
+          }
+        />
+        <Route
+          path="/profile"
+          element={
+            <ProtectedRoute fallback={<p>Chargement du profil...</p>}>
+              <Profile />
+            </ProtectedRoute>
+          }
+        />
+      </Routes>
+    </KeycloakProvider>
+  );
+}
+```
+
+```tsx
+// pages/Dashboard.tsx
+import { useAuth } from '@shane_donnelly/dsi-internal-react-utils';
+
+export default function Dashboard() {
+  const { user, token, logout } = useAuth();
+
+  return (
+    <div>
+      <h1>Bienvenue {user?.name}</h1>
+      <p>Email : {user?.email}</p>
+      <button onClick={() => logout()}>Se déconnecter</button>
+    </div>
+  );
+}
+```
+
+### Mode plug & play (sans Provider)
+
+Pour un usage rapide sans `KeycloakProvider`, passez `config` directement à `ProtectedRoute` :
+
+```tsx
+import { ProtectedRoute } from '@shane_donnelly/dsi-internal-react-utils';
+
+function App() {
+  return (
+    <ProtectedRoute
+      config={{
+        url: 'https://keycloak.example.com',
+        realm: 'my-realm',
+        clientId: 'my-frontend',
+      }}
+      idpHint="oidc"
+    >
+      <Dashboard />
+    </ProtectedRoute>
+  );
+}
+```
+
+### Utiliser le token pour les appels API
+
+```tsx
+import { useAuth } from '@shane_donnelly/dsi-internal-react-utils';
+
+function useAuthFetch() {
+  const { token } = useAuth();
+
+  return (url: string, options?: RequestInit) =>
+    fetch(url, {
+      ...options,
+      headers: {
+        ...options?.headers,
+        Authorization: `Bearer ${token}`,
+      },
+    });
+}
+```
+
+### Accéder à l'instance keycloak-js (usage avancé)
+
+```tsx
+import { useAuth } from '@shane_donnelly/dsi-internal-react-utils';
+
+function AdvancedComponent() {
+  const { keycloak } = useAuth();
+
+  // Accès direct à l'instance keycloak-js pour des cas spécifiques
+  console.log(keycloak?.tokenParsed);
+}
+```
+
+### Fonctions utilitaires standalone
+
+Deux fonctions sont disponibles pour manipuler l'instance Keycloak en dehors de React (intercepteurs HTTP, services, etc.) :
+
+```tsx
+import { useAuth, logoutKeycloak, refreshTokenKeycloak } from '@shane_donnelly/dsi-internal-react-utils';
+
+// Récupérer l'instance keycloak via useAuth()
+const { keycloak } = useAuth();
+
+// Rafraîchir le token (minValidity en secondes, défaut: 30)
+const refreshed = await refreshTokenKeycloak(keycloak!, 60);
+const freshToken = keycloak!.token;
+
+// Déconnecter l'utilisateur (redirectUri optionnel, défaut: window.location.origin)
+await logoutKeycloak(keycloak!);
+```
+
+Exemple dans un intercepteur Axios :
+
+```ts
+import axios from 'axios';
+import { logoutKeycloak, refreshTokenKeycloak } from '@shane_donnelly/dsi-internal-react-utils';
+import type Keycloak from 'keycloak-js';
+
+function setupInterceptors(keycloak: Keycloak) {
+  axios.interceptors.request.use(async (config) => {
+    await refreshTokenKeycloak(keycloak, 60);
+    config.headers.Authorization = `Bearer ${keycloak.token}`;
+    return config;
+  });
+
+  axios.interceptors.response.use(
+    (response) => response,
+    async (error) => {
+      if (error.response?.status === 401) {
+        await logoutKeycloak(keycloak);
+      }
+      return Promise.reject(error);
+    },
+  );
+}
+```

package/dist/ProtectedRoute-Bl0cCdQ2.js

@@ -0,0 +1,55 @@
+import { KeycloakProvider as e } from "./keycloak/react/KeycloakProvider/index.js";
+import { useAuth as t } from "./keycloak/react/hooks/useAuth.js";
+import { useEffect as n, useRef as r } from "react";
+import { Fragment as i, jsx as a, jsxs as o } from "react/jsx-runtime";
+import './assets/ProtectedRoute.css';var s = {
+	loadingContainer: "_loadingContainer_1th3z_1",
+	spinner: "_spinner_1th3z_11",
+	spin: "_spin_1th3z_11",
+	errorContainer: "_errorContainer_1th3z_26",
+	errorMessage: "_errorMessage_1th3z_36"
+};
+//#endregion
+//#region lib/keycloak/react/ProtectedRoute/index.tsx
+function c() {
+	return /* @__PURE__ */ o("div", {
+		className: s.loadingContainer,
+		children: [/* @__PURE__ */ a("div", { className: s.spinner }), /* @__PURE__ */ a("p", { children: "Authentication in progress..." })]
+	});
+}
+function l() {
+	return /* @__PURE__ */ a("div", {
+		className: s.errorContainer,
+		children: /* @__PURE__ */ a("p", {
+			className: s.errorMessage,
+			children: "Authentication error. Please try again later."
+		})
+	});
+}
+function u({ children: e, fallback: o, errorFallback: s }) {
+	let { status: u, login: d } = t(), f = r(!1);
+	return n(() => {
+		u === "unauthenticated" && !f.current && (f.current = !0, d().catch((e) => {
+			console.error("[dsi-keycloak] Login redirect failed:", e);
+		}));
+	}, [u, d]), u === "loading" || u === "unauthenticated" ? /* @__PURE__ */ a(i, { children: o ?? /* @__PURE__ */ a(c, {}) }) : u === "error" ? /* @__PURE__ */ a(i, { children: s ?? /* @__PURE__ */ a(l, {}) }) : /* @__PURE__ */ a(i, { children: e });
+}
+function d(e) {
+	return "config" in e && e.config != null;
+}
+function f(t) {
+	if (d(t)) {
+		let { config: n, idpHint: r, refreshInterval: i, minTokenValidity: o, onAuthError: s, ...c } = t;
+		return /* @__PURE__ */ a(e, {
+			config: n,
+			idpHint: r,
+			refreshInterval: i,
+			minTokenValidity: o,
+			onAuthError: s,
+			children: /* @__PURE__ */ a(u, { ...c })
+		});
+	}
+	return /* @__PURE__ */ a(u, { ...t });
+}
+//#endregion
+export { f as t };

package/dist/assets/ProtectedRoute.css

@@ -0,0 +1 @@
+._loadingContainer_1th3z_1{flex-direction:column;justify-content:center;align-items:center;gap:1rem;min-height:100vh;font-family:system-ui,-apple-system,sans-serif;display:flex}._spinner_1th3z_11{border:3px solid #e5e7eb;border-top-color:#3b82f6;border-radius:50%;width:40px;height:40px;animation:1s linear infinite _spin_1th3z_11}@keyframes _spin_1th3z_11{to{transform:rotate(360deg)}}._errorContainer_1th3z_26{flex-direction:column;justify-content:center;align-items:center;gap:1rem;min-height:100vh;font-family:system-ui,-apple-system,sans-serif;display:flex}._errorMessage_1th3z_36{color:#dc2626;text-align:center;background:#fef2f2;border-radius:12px;max-width:400px;padding:1.5rem}

package/dist/keycloak/core/client.d.ts

@@ -0,0 +1,60 @@
+import { default as Keycloak } from 'keycloak-js';
+import { KeycloakConfig, AuthUser } from './types';
+/**
+ * Crée une nouvelle instance keycloak-js à partir de la configuration.
+ * @param config - Configuration du serveur Keycloak
+ * @returns Instance Keycloak
+ */
+export declare function createKeycloakInstance(config: KeycloakConfig): Keycloak;
+/**
+ * Initialise une instance Keycloak avec `check-sso` et PKCE S256.
+ * Détecte automatiquement une session SSO existante sans forcer le login.
+ *
+ * @param keycloak - Instance Keycloak à initialiser
+ * @returns `true` si l'utilisateur est déjà authentifié
+ */
+export declare function initKeycloak(keycloak: Keycloak): Promise<boolean>;
+/**
+ * Extrait les informations utilisateur du token parsé Keycloak.
+ * @param keycloak - Instance Keycloak
+ * @returns Informations utilisateur ou `null`
+ */
+export declare function parseUser(keycloak: Keycloak): AuthUser | null;
+/**
+ * Déconnecte l'utilisateur via l'instance Keycloak.
+ *
+ * Utilisable en dehors de React (ex: intercepteur HTTP, service, guard).
+ *
+ * @param keycloak - Instance Keycloak (récupérable via `useAuth().keycloak`)
+ * @param redirectUri - URL de redirection après déconnexion (défaut: `window.location.origin`)
+ *
+ * @example
+ * ```ts
+ * import { logoutKeycloak } from '@shane_donnelly/dsi-internal-react-utils';
+ *
+ * // dans un intercepteur axios
+ * if (response.status === 401) {
+ *   await logoutKeycloak(keycloakInstance);
+ * }
+ * ```
+ */
+export declare function logoutKeycloak(keycloak: Keycloak, redirectUri?: string): Promise<void>;
+/**
+ * Rafraîchit le token d'accès via l'instance Keycloak.
+ *
+ * Utilisable en dehors de React (ex: intercepteur HTTP, service).
+ *
+ * @param keycloak - Instance Keycloak (récupérable via `useAuth().keycloak`)
+ * @param minValidity - Durée minimale de validité restante en secondes (défaut: 30)
+ * @returns `true` si le token a été rafraîchi, `false` sinon
+ *
+ * @example
+ * ```ts
+ * import { refreshTokenKeycloak } from '@shane_donnelly/dsi-internal-react-utils';
+ *
+ * // avant un appel API
+ * await refreshTokenKeycloak(keycloakInstance, 60);
+ * const token = keycloakInstance.token;
+ * ```
+ */
+export declare function refreshTokenKeycloak(keycloak: Keycloak, minValidity?: number): Promise<boolean>;

package/dist/keycloak/core/client.js

@@ -0,0 +1,35 @@
+import e from "keycloak-js";
+//#region lib/keycloak/core/client.ts
+function t(t) {
+	return new e({
+		url: t.url,
+		realm: t.realm,
+		clientId: t.clientId
+	});
+}
+async function n(e) {
+	try {
+		return await e.init({
+			onLoad: "check-sso",
+			pkceMethod: "S256",
+			checkLoginIframe: !1
+		});
+	} catch (e) {
+		return console.error("[dsi-keycloak] Init failed:", e), !1;
+	}
+}
+function r(e) {
+	return e.tokenParsed ? e.tokenParsed : null;
+}
+async function i(e, t) {
+	await e.logout({ redirectUri: t ?? window.location.origin });
+}
+async function a(e, t = 30) {
+	try {
+		return await e.updateToken(t);
+	} catch (e) {
+		return console.warn("[dsi-keycloak] Token refresh failed:", e), !1;
+	}
+}
+//#endregion
+export { t as createKeycloakInstance, n as initKeycloak, i as logoutKeycloak, r as parseUser, a as refreshTokenKeycloak };

package/dist/keycloak/core/types.d.ts

@@ -0,0 +1,67 @@
+import { default as Keycloak } from 'keycloak-js';
+/**
+ * Configuration du serveur Keycloak.
+ */
+export type KeycloakConfig = {
+    /** URL du serveur Keycloak (ex: "https://keycloak.example.com") */
+    url: string;
+    /** Nom du realm Keycloak */
+    realm: string;
+    /** Client ID de l'application */
+    clientId: string;
+};
+/**
+ * Options d'authentification pour le module Keycloak.
+ */
+export type KeycloakAuthOptions = {
+    /** Hint d'identity provider pour redirection directe (ex: "oidc", "microsoft", "google") */
+    idpHint?: string;
+    /** Intervalle de rafraîchissement du token en secondes (défaut: 300 = 5min) */
+    refreshInterval?: number;
+    /** Validité minimale du token en secondes avant rafraîchissement (défaut: 30) */
+    minTokenValidity?: number;
+    /** Comportement en cas d'erreur d'auth: 'login' pour rediriger, 'logout' pour déconnecter, ou un handler custom */
+    onAuthError?: 'login' | 'logout' | ((error: unknown) => void);
+};
+/**
+ * État de l'authentification.
+ * - `loading` : vérification en cours
+ * - `authenticated` : utilisateur connecté
+ * - `unauthenticated` : utilisateur non connecté
+ * - `error` : erreur lors de l'initialisation
+ */
+export type AuthStatus = 'loading' | 'authenticated' | 'unauthenticated' | 'error';
+/**
+ * Informations utilisateur extraites du token Keycloak.
+ * Contient les claims standard OpenID Connect + toute claim custom.
+ */
+export type AuthUser = {
+    sub?: string;
+    name?: string;
+    email?: string;
+    preferred_username?: string;
+    given_name?: string;
+    family_name?: string;
+    [key: string]: unknown;
+};
+/**
+ * Valeur du contexte d'authentification exposée par `KeycloakProvider` et `useAuth`.
+ */
+export type AuthContextValue = {
+    /** État actuel de l'authentification */
+    status: AuthStatus;
+    /** Token d'accès brut (null si non authentifié) */
+    token: string | null;
+    /** Informations utilisateur extraites du token */
+    user: AuthUser | null;
+    /** Raccourci pour `status === 'authenticated'` */
+    isAuthenticated: boolean;
+    /** Instance keycloak-js sous-jacente (pour usage avancé) */
+    keycloak: Keycloak | null;
+    /** Déclencher une redirection de login. Accepte un idpHint optionnel pour override celui du Provider. */
+    login: (idpHint?: string) => Promise<void>;
+    /** Déclencher un logout. Accepte un redirectUri optionnel (défaut: origin). */
+    logout: (redirectUri?: string) => Promise<void>;
+    /** Rafraîchir manuellement le token. Retourne true si réussi. */
+    refreshToken: () => Promise<boolean>;
+};

package/dist/keycloak/index.d.ts

@@ -0,0 +1,7 @@
+export { KeycloakProvider } from './react/KeycloakProvider';
+export type { KeycloakProviderProps } from './react/KeycloakProvider';
+export { ProtectedRoute } from './react/ProtectedRoute';
+export type { ProtectedRouteProps } from './react/ProtectedRoute';
+export { useAuth } from './react/hooks/useAuth';
+export { logoutKeycloak, refreshTokenKeycloak } from './core/client';
+export type { KeycloakConfig, KeycloakAuthOptions, AuthStatus, AuthUser, AuthContextValue, } from './core/types';

package/dist/keycloak/index.js

@@ -0,0 +1,5 @@
+import { logoutKeycloak as e, refreshTokenKeycloak as t } from "./core/client.js";
+import { KeycloakProvider as n } from "./react/KeycloakProvider/index.js";
+import { useAuth as r } from "./react/hooks/useAuth.js";
+import { t as i } from "../ProtectedRoute-Bl0cCdQ2.js";
+export { n as KeycloakProvider, i as ProtectedRoute, e as logoutKeycloak, t as refreshTokenKeycloak, r as useAuth };

package/dist/keycloak/react/KeycloakProvider/index.d.ts

@@ -0,0 +1,37 @@
+import { ReactNode } from 'react';
+import { AuthContextValue, KeycloakConfig, KeycloakAuthOptions } from '../../core/types';
+/**
+ * Contexte React pour l'authentification Keycloak.
+ * Utilisé en interne par `useAuth` et `ProtectedRoute`.
+ */
+export declare const KeycloakAuthContext: import('react').Context<AuthContextValue | null>;
+/**
+ * Props du composant `KeycloakProvider`.
+ */
+export interface KeycloakProviderProps extends KeycloakAuthOptions {
+    /** Configuration du serveur Keycloak */
+    config: KeycloakConfig;
+    /** Contenu de l'application */
+    children: ReactNode;
+}
+/**
+ * Provider d'authentification Keycloak.
+ *
+ * Initialise la connexion Keycloak, gère le cycle de vie des tokens
+ * (rafraîchissement automatique par intervalle et au retour de l'onglet),
+ * et expose l'état d'authentification via le contexte React.
+ *
+ * Basé sur `keycloak-js`. Utilise `check-sso` avec PKCE S256.
+ *
+ * @example
+ * ```tsx
+ * <KeycloakProvider
+ *   config={{ url: 'https://keycloak.example.com', realm: 'my-realm', clientId: 'my-client' }}
+ *   idpHint="oidc"
+ *   refreshInterval={300}
+ * >
+ *   <App />
+ * </KeycloakProvider>
+ * ```
+ */
+export declare function KeycloakProvider({ config, children, idpHint, refreshInterval, minTokenValidity, onAuthError, }: KeycloakProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/keycloak/react/KeycloakProvider/index.js

@@ -0,0 +1,70 @@
+import { createKeycloakInstance as e, initKeycloak as t, parseUser as n } from "../../core/client.js";
+import { createContext as r, useCallback as i, useEffect as a, useRef as o, useState as s } from "react";
+import { jsx as c } from "react/jsx-runtime";
+//#region lib/keycloak/react/KeycloakProvider/index.tsx
+var l = r(null);
+function u({ config: r, children: u, idpHint: d, refreshInterval: f = 300, minTokenValidity: p = 30, onAuthError: m }) {
+	let [h, g] = s("loading"), [_, v] = s(null), [y, b] = s(null), x = o(null), S = o(!1), C = i((e) => {
+		e.authenticated && e.token ? (v(e.token), b(n(e)), g("authenticated")) : (v(null), b(null), g("unauthenticated"));
+	}, []), w = i(async (e) => {
+		m === "login" ? await x.current?.login({ idpHint: d }) : m === "logout" ? await x.current?.logout({ redirectUri: window.location.origin }) : typeof m == "function" && m(e);
+	}, [m, d]), T = i(async () => {
+		let e = x.current;
+		if (!e) return !1;
+		try {
+			return await e.updateToken(p) && C(e), !0;
+		} catch (e) {
+			return console.warn("[dsi-keycloak] Token refresh failed:", e), await w(e), !1;
+		}
+	}, [
+		p,
+		C,
+		w
+	]);
+	a(() => {
+		if (S.current) return;
+		S.current = !0;
+		let n = e(r);
+		x.current = n, t(n).then((e) => {
+			C(n), e || g("unauthenticated");
+		}).catch((e) => {
+			console.error("[dsi-keycloak] Init error:", e), g("error");
+		});
+	}, []), a(() => {
+		if (h !== "authenticated") return;
+		let e = window.setInterval(() => {
+			T();
+		}, f * 1e3), t = () => {
+			document.visibilityState === "visible" && T();
+		};
+		return document.addEventListener("visibilitychange", t), () => {
+			clearInterval(e), document.removeEventListener("visibilitychange", t);
+		};
+	}, [
+		h,
+		f,
+		T
+	]);
+	let E = i(async (e) => {
+		let t = x.current;
+		t && await t.login({ idpHint: e ?? d });
+	}, [d]), D = i(async (e) => {
+		let t = x.current;
+		t && await t.logout({ redirectUri: e ?? window.location.origin });
+	}, []), O = {
+		status: h,
+		token: _,
+		user: y,
+		isAuthenticated: h === "authenticated",
+		keycloak: x.current,
+		login: E,
+		logout: D,
+		refreshToken: T
+	};
+	return /* @__PURE__ */ c(l.Provider, {
+		value: O,
+		children: u
+	});
+}
+//#endregion
+export { l as KeycloakAuthContext, u as KeycloakProvider };

package/dist/keycloak/react/ProtectedRoute/index.d.ts

@@ -0,0 +1,69 @@
+import { ReactNode } from 'react';
+import { KeycloakConfig, KeycloakAuthOptions } from '../../core/types';
+/**
+ * Props de base du composant `ProtectedRoute`.
+ */
+interface BaseProtectedRouteProps {
+    /** Contenu protégé, affiché une fois authentifié */
+    children: ReactNode;
+    /** Composant affiché pendant le chargement / la redirection (défaut: spinner) */
+    fallback?: ReactNode;
+    /** Composant affiché en cas d'erreur d'authentification (défaut: message d'erreur) */
+    errorFallback?: ReactNode;
+}
+/**
+ * Props pour le mode standalone (sans `KeycloakProvider` parent).
+ * Inclut la configuration Keycloak et les options d'authentification.
+ */
+interface StandaloneProtectedRouteProps extends BaseProtectedRouteProps, KeycloakAuthOptions {
+    /** Configuration du serveur Keycloak */
+    config: KeycloakConfig;
+}
+/**
+ * Props pour le mode contexte (à l'intérieur d'un `KeycloakProvider`).
+ */
+type ContextProtectedRouteProps = BaseProtectedRouteProps;
+/**
+ * Union des props acceptées par `ProtectedRoute`.
+ */
+export type ProtectedRouteProps = StandaloneProtectedRouteProps | ContextProtectedRouteProps;
+/**
+ * Composant de protection de route / zone authentifiée.
+ *
+ * Fonctionne en deux modes :
+ *
+ * **Mode standalone** (plug & play) : fournir `config` et les options directement.
+ * Crée automatiquement un `KeycloakProvider` interne.
+ *
+ * **Mode contexte** : utiliser à l'intérieur d'un `KeycloakProvider` parent.
+ * Ne nécessite que `children` et optionnellement `fallback` / `errorFallback`.
+ *
+ * Dans les deux cas, le composant :
+ * - Vérifie l'état d'authentification via `check-sso`
+ * - Redirige vers le login Keycloak (via l'IDP configuré) si non authentifié
+ * - Affiche un fallback pendant le chargement
+ * - Rend les enfants une fois authentifié
+ *
+ * Basé sur `keycloak-js`.
+ *
+ * @example Mode standalone (plug & play)
+ * ```tsx
+ * <ProtectedRoute
+ *   config={{ url: 'https://keycloak.example.com', realm: 'my-realm', clientId: 'my-client' }}
+ *   idpHint="oidc"
+ * >
+ *   <Dashboard />
+ * </ProtectedRoute>
+ * ```
+ *
+ * @example Mode contexte (avec KeycloakProvider parent)
+ * ```tsx
+ * <KeycloakProvider config={...} idpHint="oidc">
+ *   <ProtectedRoute>
+ *     <Dashboard />
+ *   </ProtectedRoute>
+ * </KeycloakProvider>
+ * ```
+ */
+export declare function ProtectedRoute(props: ProtectedRouteProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/keycloak/react/ProtectedRoute/index.js

@@ -0,0 +1,2 @@
+import { t as e } from "../../../ProtectedRoute-Bl0cCdQ2.js";
+export { e as ProtectedRoute };

package/dist/keycloak/react/hooks/useAuth.d.ts

@@ -0,0 +1,39 @@
+import { AuthContextValue } from '../../core/types';
+/**
+ * Hook d'authentification Keycloak.
+ *
+ * Donne accès à l'état d'authentification, au token, aux infos utilisateur,
+ * et aux actions (login, logout, refreshToken).
+ *
+ * Doit être utilisé à l'intérieur d'un `KeycloakProvider` ou d'un `ProtectedRoute` avec `config`.
+ *
+ * @returns Objet d'authentification complet
+ *
+ * @example
+ * ```tsx
+ * function UserProfile() {
+ *   const { user, token, isAuthenticated, logout } = useAuth();
+ *
+ *   if (!isAuthenticated) return null;
+ *
+ *   return (
+ *     <div>
+ *       <p>Bonjour {user?.name}</p>
+ *       <button onClick={() => logout()}>Déconnexion</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example Utiliser le token pour des appels API
+ * ```tsx
+ * function useFetchWithAuth(url: string) {
+ *   const { token } = useAuth();
+ *
+ *   return fetch(url, {
+ *     headers: { Authorization: `Bearer ${token}` },
+ *   });
+ * }
+ * ```
+ */
+export declare function useAuth(): AuthContextValue;

package/dist/keycloak/react/hooks/useAuth.js

@@ -0,0 +1,10 @@
+import { KeycloakAuthContext as e } from "../KeycloakProvider/index.js";
+import { useContext as t } from "react";
+//#region lib/keycloak/react/hooks/useAuth.ts
+function n() {
+	let n = t(e);
+	if (!n) throw Error("[dsi-keycloak] useAuth() must be used within a <KeycloakProvider> or a <ProtectedRoute config={...}>.");
+	return n;
+}
+//#endregion
+export { n as useAuth };

package/dist/main.d.ts

@@ -1 +1,2 @@
-export { Example } from './components/Example';
+export { KeycloakProvider, ProtectedRoute, useAuth, logoutKeycloak, refreshTokenKeycloak, } from './keycloak';
+export type { KeycloakProviderProps, ProtectedRouteProps, KeycloakConfig, KeycloakAuthOptions, AuthStatus, AuthUser, AuthContextValue, } from './keycloak';

package/dist/main.js

@@ -1,2 +1,6 @@
-import { t as e } from "./Example-CYi9vFcY.js";
-export { e as Example };
+import { logoutKeycloak as e, refreshTokenKeycloak as t } from "./keycloak/core/client.js";
+import { KeycloakProvider as n } from "./keycloak/react/KeycloakProvider/index.js";
+import { useAuth as r } from "./keycloak/react/hooks/useAuth.js";
+import { t as i } from "./ProtectedRoute-Bl0cCdQ2.js";
+import "./keycloak/index.js";
+export { n as KeycloakProvider, i as ProtectedRoute, e as logoutKeycloak, t as refreshTokenKeycloak, r as useAuth };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shane_donnelly/dsi-internal-react-utils",
   "private": false,
-  "version": "0.0.2",
+  "version": "0.1.1",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -28,7 +28,8 @@
     "vite-plugin-dts": "^4.5.4",
     "vite-plugin-lib-inject-css": "^2.2.2",
     "react": "^19.2.4",
-    "react-dom": "^19.2.4"
+    "react-dom": "^19.2.4",
+    "keycloak-js": "^26.0.0"
   },
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
@@ -40,6 +41,7 @@
   ],
   "peerDependencies": {
     "react": "^19.2.4",
-    "react-dom": "^19.2.4"
+    "react-dom": "^19.2.4",
+    "keycloak-js": ">=25.0.0"
   }
 }

package/dist/Example-CYi9vFcY.js

@@ -1,12 +0,0 @@
-import { jsx as e } from "react/jsx-runtime";
-import './assets/Example.css';var t = { text: "_text_acpj5_1" };
-//#endregion
-//#region lib/components/Example/index.tsx
-function n() {
-	return /* @__PURE__ */ e("p", {
-		className: t.text,
-		children: "Example"
-	});
-}
-//#endregion
-export { n as t };

package/dist/assets/Example.css

@@ -1 +0,0 @@
-._text_acpj5_1{color:red}

package/dist/components/Example/index.d.ts

@@ -1 +0,0 @@
-export declare function Example(): import("react/jsx-runtime").JSX.Element;

package/dist/components/Example/index.js

@@ -1,2 +0,0 @@
-import { t as e } from "../../Example-CYi9vFcY.js";
-export { e as Example };