@eventuras/fides-auth-react 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Losol AS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# @eventuras/fides-auth-react
+
+React hooks for [`@eventuras/fides-auth`](../fides-auth) — thin bindings over the
+framework-agnostic building blocks:
+
+- **`createAuthStoreHooks(store)`** → `useAuthStore` / `useAuthActions` for an
+  [`@eventuras/fides-auth-store`](../fides-auth-store) auth store.
+- **`useSessionMonitor(store, checkAuthStatus, config?)`** → runs
+  `startSessionMonitor` with `useEffect` cleanup.
+- **`useHeartbeat(config?)`** → runs the `@eventuras/fides-auth` heartbeat engine
+  to keep the session alive for active users.
+
+The heavy logic lives in the packages these wrap (the heartbeat engine in
+`@eventuras/fides-auth`, the store and session monitor in
+`@eventuras/fides-auth-store`); this package only adds the React lifecycle glue.
+
+## Install
+
+```bash
+pnpm add @eventuras/fides-auth-react
+```
+
+`react`, `@xstate/store`, and `@xstate/store-react` are peer dependencies.
+
+## Usage
+
+```tsx
+'use client';
+import {
+  createAuthStoreHooks,
+  useSessionMonitor,
+  useHeartbeat,
+} from '@eventuras/fides-auth-react';
+import { authStore, checkAuthStatus } from './auth';
+
+export const { useAuthStore, useAuthActions } = createAuthStoreHooks(authStore);
+
+export function AuthProvider({ children }: { children: React.ReactNode }) {
+  useSessionMonitor(authStore, checkAuthStatus);
+  useHeartbeat({
+    onSessionExpired: () => authStore.send({ type: 'sessionExpired' }),
+  });
+  return <>{children}</>;
+}
+
+function Profile() {
+  const auth = useAuthStore();
+  const { logout } = useAuthActions();
+  if (auth.isInitializing) return null;
+  return auth.isAuthenticated ? (
+    <button onClick={logout}>Log out {auth.user?.name}</button>
+  ) : (
+    <a href='/login'>Log in</a>
+  );
+}
+```

package/dist/hooks.d.ts

@@ -0,0 +1,63 @@
+import { SessionUser, createAuthStore } from '@eventuras/fides-auth-store';
+/**
+ * Return type for store-based auth hooks
+ */
+export type AuthStoreSelector = {
+    isAuthenticated: boolean;
+    isAdmin: boolean;
+    user: SessionUser | null;
+    error: string | null;
+    lastChecked: Date | null;
+    isInitializing: boolean;
+};
+/**
+ * Actions for store-based auth
+ */
+export type AuthStoreActions = {
+    loginSuccess: (user: SessionUser) => void;
+    logout: () => void;
+    sessionExpired: () => void;
+    authSuccess: (user: SessionUser) => void;
+    authFailed: (error?: string) => void;
+    setError: (error: string) => void;
+    clearError: () => void;
+};
+/**
+ * Creates React hooks for interacting with the auth store
+ *
+ * @param store - The XState store instance
+ * @returns Object containing useAuthStore hook
+ *
+ * @example
+ * ```typescript
+ * const authStore = createAuthStore({
+ *   checkAuthStatus: getAuthStatus,
+ * });
+ *
+ * export const { useAuthStore } = createAuthStoreHooks(authStore);
+ *
+ * // In component
+ * function MyComponent() {
+ *   const auth = useAuthStore();
+ *
+ *   if (auth.error) {
+ *     toast.error(auth.error);
+ *   }
+ *
+ *   if (auth.isInitializing) {
+ *     return <Spinner />;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       {auth.isAuthenticated ? `Hello ${auth.user?.name}` : 'Please login'}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function createAuthStoreHooks(store: ReturnType<typeof createAuthStore>): {
+    useAuthStore: () => AuthStoreSelector;
+    useAuthActions: () => AuthStoreActions;
+};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAEhF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,eAAe,EAAE,OAAO,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,EAAE,IAAI,GAAG,IAAI,CAAC;IACzB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC;IAC1C,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,WAAW,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC;IACzC,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC;wBAInD,iBAAiB;0BAQf,gBAAgB;EAgB5C"}

package/dist/hooks.js

@@ -0,0 +1,78 @@
+import { useSelector } from "@xstate/store-react";
+//#region src/hooks.ts
+/**
+* Creates React hooks for interacting with the auth store
+*
+* @param store - The XState store instance
+* @returns Object containing useAuthStore hook
+*
+* @example
+* ```typescript
+* const authStore = createAuthStore({
+*   checkAuthStatus: getAuthStatus,
+* });
+*
+* export const { useAuthStore } = createAuthStoreHooks(authStore);
+*
+* // In component
+* function MyComponent() {
+*   const auth = useAuthStore();
+*
+*   if (auth.error) {
+*     toast.error(auth.error);
+*   }
+*
+*   if (auth.isInitializing) {
+*     return <Spinner />;
+*   }
+*
+*   return (
+*     <div>
+*       {auth.isAuthenticated ? `Hello ${auth.user?.name}` : 'Please login'}
+*     </div>
+*   );
+* }
+* ```
+*/
+function createAuthStoreHooks(store) {
+	/**
+	* Hook to access the auth store state
+	*/
+	function useAuthStore() {
+		return useSelector(store, (snapshot) => snapshot).context;
+	}
+	/**
+	* Hook to get auth store actions
+	*/
+	function useAuthActions() {
+		return {
+			loginSuccess: (user) => store.send({
+				type: "loginSuccess",
+				user
+			}),
+			logout: () => store.send({ type: "logout" }),
+			sessionExpired: () => store.send({ type: "sessionExpired" }),
+			authSuccess: (user) => store.send({
+				type: "authSuccess",
+				user
+			}),
+			authFailed: (error) => store.send({
+				type: "authFailed",
+				error
+			}),
+			setError: (error) => store.send({
+				type: "setError",
+				error
+			}),
+			clearError: () => store.send({ type: "clearError" })
+		};
+	}
+	return {
+		useAuthStore,
+		useAuthActions
+	};
+}
+//#endregion
+export { createAuthStoreHooks };
+
+//# sourceMappingURL=hooks.js.map

package/dist/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","names":[],"sources":["../src/hooks.ts"],"sourcesContent":["import { useSelector as useStoreSelector } from '@xstate/store-react';\nimport type { SessionUser, createAuthStore } from '@eventuras/fides-auth-store';\n\n/**\n * Return type for store-based auth hooks\n */\nexport type AuthStoreSelector = {\n  isAuthenticated: boolean;\n  isAdmin: boolean;\n  user: SessionUser | null;\n  error: string | null;\n  lastChecked: Date | null;\n  isInitializing: boolean;\n};\n\n/**\n * Actions for store-based auth\n */\nexport type AuthStoreActions = {\n  loginSuccess: (user: SessionUser) => void;\n  logout: () => void;\n  sessionExpired: () => void;\n  authSuccess: (user: SessionUser) => void;\n  authFailed: (error?: string) => void;\n  setError: (error: string) => void;\n  clearError: () => void;\n};\n\n/**\n * Creates React hooks for interacting with the auth store\n *\n * @param store - The XState store instance\n * @returns Object containing useAuthStore hook\n *\n * @example\n * ```typescript\n * const authStore = createAuthStore({\n *   checkAuthStatus: getAuthStatus,\n * });\n *\n * export const { useAuthStore } = createAuthStoreHooks(authStore);\n *\n * // In component\n * function MyComponent() {\n *   const auth = useAuthStore();\n *\n *   if (auth.error) {\n *     toast.error(auth.error);\n *   }\n *\n *   if (auth.isInitializing) {\n *     return <Spinner />;\n *   }\n *\n *   return (\n *     <div>\n *       {auth.isAuthenticated ? `Hello ${auth.user?.name}` : 'Please login'}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function createAuthStoreHooks(store: ReturnType<typeof createAuthStore>) {\n  /**\n   * Hook to access the auth store state\n   */\n  function useAuthStore(): AuthStoreSelector {\n    const snapshot = useStoreSelector(store, (snapshot) => snapshot);\n    return snapshot.context;\n  }\n\n  /**\n   * Hook to get auth store actions\n   */\n  function useAuthActions(): AuthStoreActions {\n    return {\n      loginSuccess: (user: SessionUser) => store.send({ type: 'loginSuccess', user }),\n      logout: () => store.send({ type: 'logout' }),\n      sessionExpired: () => store.send({ type: 'sessionExpired' }),\n      authSuccess: (user: SessionUser) => store.send({ type: 'authSuccess', user }),\n      authFailed: (error?: string) => store.send({ type: 'authFailed', error }),\n      setError: (error: string) => store.send({ type: 'setError', error }),\n      clearError: () => store.send({ type: 'clearError' }),\n    };\n  }\n\n  return {\n    useAuthStore,\n    useAuthActions,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,SAAgB,qBAAqB,OAA2C;;;;CAI9E,SAAS,eAAkC;EAEzC,OADiB,YAAiB,QAAQ,aAAa,QAChD,EAAS;CAClB;;;;CAKA,SAAS,iBAAmC;EAC1C,OAAO;GACL,eAAe,SAAsB,MAAM,KAAK;IAAE,MAAM;IAAgB;GAAK,CAAC;GAC9E,cAAc,MAAM,KAAK,EAAE,MAAM,SAAS,CAAC;GAC3C,sBAAsB,MAAM,KAAK,EAAE,MAAM,iBAAiB,CAAC;GAC3D,cAAc,SAAsB,MAAM,KAAK;IAAE,MAAM;IAAe;GAAK,CAAC;GAC5E,aAAa,UAAmB,MAAM,KAAK;IAAE,MAAM;IAAc;GAAM,CAAC;GACxE,WAAW,UAAkB,MAAM,KAAK;IAAE,MAAM;IAAY;GAAM,CAAC;GACnE,kBAAkB,MAAM,KAAK,EAAE,MAAM,aAAa,CAAC;EACrD;CACF;CAEA,OAAO;EACL;EACA;CACF;AACF"}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * React bindings for @eventuras/fides-auth.
+ *
+ * Thin React hooks over the framework-agnostic building blocks:
+ * - {@link createAuthStoreHooks} — `useAuthStore` / `useAuthActions` over an
+ *   `@eventuras/fides-auth-store` auth store.
+ * - {@link useSessionMonitor} — runs `startSessionMonitor` with `useEffect` cleanup.
+ * - {@link useHeartbeat} — runs the `@eventuras/fides-auth` heartbeat engine.
+ *
+ * Pair these with `@eventuras/fides-auth-store` (the store + status checks) and a
+ * server adapter such as `@eventuras/fides-auth-next` (cookies, route handlers).
+ *
+ * @example
+ * ```tsx
+ * 'use client';
+ * import { createAuthStoreHooks, useSessionMonitor, useHeartbeat } from '@eventuras/fides-auth-react';
+ * import { authStore, checkAuthStatus } from './auth';
+ *
+ * export const { useAuthStore, useAuthActions } = createAuthStoreHooks(authStore);
+ *
+ * export function AuthProvider({ children }: { children: React.ReactNode }) {
+ *   useSessionMonitor(authStore, checkAuthStatus);
+ *   useHeartbeat({ onSessionExpired: () => authStore.send({ type: 'sessionExpired' }) });
+ *   return <>{children}</>;
+ * }
+ * ```
+ */
+export { createAuthStoreHooks, type AuthStoreSelector, type AuthStoreActions, } from './hooks';
+export { useSessionMonitor } from './use-session-monitor';
+export { useHeartbeat, type HeartbeatConfig } from './use-heartbeat';
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EACL,oBAAoB,EACpB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+import { createAuthStoreHooks } from "./hooks.js";
+import { useSessionMonitor } from "./use-session-monitor.js";
+import { useHeartbeat } from "./use-heartbeat.js";
+export { createAuthStoreHooks, useHeartbeat, useSessionMonitor };

package/dist/use-heartbeat.d.ts

@@ -0,0 +1,27 @@
+import { HeartbeatConfig } from '@eventuras/fides-auth/heartbeat';
+export type { HeartbeatConfig };
+/**
+ * React wrapper around the framework-agnostic {@link createHeartbeat} engine.
+ *
+ * Starts the heartbeat on mount and stops it on unmount. Callbacks are read
+ * through a ref so changing their identity between renders does not restart the
+ * engine; the primitive options are the effect's dependencies.
+ *
+ * Intended to be paired with {@link useSessionMonitor}: the monitor *detects*
+ * session loss; this hook *prevents* it for active users. See
+ * {@link HeartbeatConfig} for the tuning knobs.
+ *
+ * @example
+ * ```tsx
+ * 'use client';
+ * import { useHeartbeat, useSessionMonitor } from '@eventuras/fides-auth-react';
+ *
+ * function AuthProvider({ children }) {
+ *   useSessionMonitor(authStore, checkAuthStatus);
+ *   useHeartbeat({ onSessionExpired: () => authStore.send({ type: 'sessionExpired' }) });
+ *   return <>{children}</>;
+ * }
+ * ```
+ */
+export declare function useHeartbeat(config?: HeartbeatConfig): void;
+//# sourceMappingURL=use-heartbeat.d.ts.map

package/dist/use-heartbeat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-heartbeat.d.ts","sourceRoot":"","sources":["../src/use-heartbeat.ts"],"names":[],"mappings":"AAGA,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAExF,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,MAAM,GAAE,eAAoB,GAAG,IAAI,CAsC/D"}

package/dist/use-heartbeat.js

@@ -0,0 +1,58 @@
+"use client";
+import { useEffect, useRef } from "react";
+import { createHeartbeat } from "@eventuras/fides-auth/heartbeat";
+//#region src/use-heartbeat.ts
+/**
+* React wrapper around the framework-agnostic {@link createHeartbeat} engine.
+*
+* Starts the heartbeat on mount and stops it on unmount. Callbacks are read
+* through a ref so changing their identity between renders does not restart the
+* engine; the primitive options are the effect's dependencies.
+*
+* Intended to be paired with {@link useSessionMonitor}: the monitor *detects*
+* session loss; this hook *prevents* it for active users. See
+* {@link HeartbeatConfig} for the tuning knobs.
+*
+* @example
+* ```tsx
+* 'use client';
+* import { useHeartbeat, useSessionMonitor } from '@eventuras/fides-auth-react';
+*
+* function AuthProvider({ children }) {
+*   useSessionMonitor(authStore, checkAuthStatus);
+*   useHeartbeat({ onSessionExpired: () => authStore.send({ type: 'sessionExpired' }) });
+*   return <>{children}</>;
+* }
+* ```
+*/
+function useHeartbeat(config = {}) {
+	const { endpoint, fraction, minSkewMs, minRefreshIntervalMs, idleThresholdMs, initialExpiresAt, loggerNamespace } = config;
+	const callbacksRef = useRef(config);
+	callbacksRef.current = config;
+	useEffect(() => {
+		return createHeartbeat({
+			endpoint,
+			fraction,
+			minSkewMs,
+			minRefreshIntervalMs,
+			idleThresholdMs,
+			initialExpiresAt,
+			loggerNamespace,
+			onSessionExpired: () => callbacksRef.current.onSessionExpired?.(),
+			onRefreshed: () => callbacksRef.current.onRefreshed?.(),
+			onError: (error) => callbacksRef.current.onError?.(error)
+		}).stop;
+	}, [
+		endpoint,
+		fraction,
+		minSkewMs,
+		minRefreshIntervalMs,
+		idleThresholdMs,
+		initialExpiresAt,
+		loggerNamespace
+	]);
+}
+//#endregion
+export { useHeartbeat };
+
+//# sourceMappingURL=use-heartbeat.js.map

package/dist/use-heartbeat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-heartbeat.js","names":[],"sources":["../src/use-heartbeat.ts"],"sourcesContent":["'use client';\n\nimport { useEffect, useRef } from 'react';\nimport { createHeartbeat, type HeartbeatConfig } from '@eventuras/fides-auth/heartbeat';\n\nexport type { HeartbeatConfig };\n\n/**\n * React wrapper around the framework-agnostic {@link createHeartbeat} engine.\n *\n * Starts the heartbeat on mount and stops it on unmount. Callbacks are read\n * through a ref so changing their identity between renders does not restart the\n * engine; the primitive options are the effect's dependencies.\n *\n * Intended to be paired with {@link useSessionMonitor}: the monitor *detects*\n * session loss; this hook *prevents* it for active users. See\n * {@link HeartbeatConfig} for the tuning knobs.\n *\n * @example\n * ```tsx\n * 'use client';\n * import { useHeartbeat, useSessionMonitor } from '@eventuras/fides-auth-react';\n *\n * function AuthProvider({ children }) {\n *   useSessionMonitor(authStore, checkAuthStatus);\n *   useHeartbeat({ onSessionExpired: () => authStore.send({ type: 'sessionExpired' }) });\n *   return <>{children}</>;\n * }\n * ```\n */\nexport function useHeartbeat(config: HeartbeatConfig = {}): void {\n  const {\n    endpoint,\n    fraction,\n    minSkewMs,\n    minRefreshIntervalMs,\n    idleThresholdMs,\n    initialExpiresAt,\n    loggerNamespace,\n  } = config;\n\n  // Keep callbacks current without re-running the effect when their identities change.\n  const callbacksRef = useRef(config);\n  callbacksRef.current = config;\n\n  useEffect(() => {\n    const handle = createHeartbeat({\n      endpoint,\n      fraction,\n      minSkewMs,\n      minRefreshIntervalMs,\n      idleThresholdMs,\n      initialExpiresAt,\n      loggerNamespace,\n      onSessionExpired: () => callbacksRef.current.onSessionExpired?.(),\n      onRefreshed: () => callbacksRef.current.onRefreshed?.(),\n      onError: (error) => callbacksRef.current.onError?.(error),\n    });\n    return handle.stop;\n  }, [\n    endpoint,\n    fraction,\n    minSkewMs,\n    minRefreshIntervalMs,\n    idleThresholdMs,\n    initialExpiresAt,\n    loggerNamespace,\n  ]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,aAAa,SAA0B,CAAC,GAAS;CAC/D,MAAM,EACJ,UACA,UACA,WACA,sBACA,iBACA,kBACA,oBACE;CAGJ,MAAM,eAAe,OAAO,MAAM;CAClC,aAAa,UAAU;CAEvB,gBAAgB;EAad,OAZe,gBAAgB;GAC7B;GACA;GACA;GACA;GACA;GACA;GACA;GACA,wBAAwB,aAAa,QAAQ,mBAAmB;GAChE,mBAAmB,aAAa,QAAQ,cAAc;GACtD,UAAU,UAAU,aAAa,QAAQ,UAAU,KAAK;EAC1D,CACO,EAAO;CAChB,GAAG;EACD;EACA;EACA;EACA;EACA;EACA;EACA;CACF,CAAC;AACH"}

package/dist/use-session-monitor.d.ts

@@ -0,0 +1,26 @@
+import { SessionMonitorConfig, AuthStatus, createAuthStore } from '@eventuras/fides-auth-store';
+/**
+ * React hook for session monitoring with automatic cleanup
+ *
+ * @param store - The auth store to update
+ * @param checkAuthStatus - Function to check authentication status
+ * @param config - Optional configuration
+ *
+ * @example
+ * ```typescript
+ * import { useSessionMonitor } from '@eventuras/fides-auth-react';
+ *
+ * function App() {
+ *   useSessionMonitor(authStore, checkAuthStatus, {
+ *     interval: 30_000,
+ *     onSessionExpired: () => {
+ *       toast.warn('Your session has expired');
+ *     }
+ *   });
+ *
+ *   return <div>...</div>;
+ * }
+ * ```
+ */
+export declare function useSessionMonitor(store: ReturnType<typeof createAuthStore>, checkAuthStatus: () => Promise<AuthStatus>, config?: SessionMonitorConfig): void;
+//# sourceMappingURL=use-session-monitor.d.ts.map

package/dist/use-session-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-session-monitor.d.ts","sourceRoot":"","sources":["../src/use-session-monitor.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,UAAU,EACf,KAAK,eAAe,EACrB,MAAM,6BAA6B,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,EACzC,eAAe,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,EAC1C,MAAM,GAAE,oBAAyB,GAChC,IAAI,CAIN"}

package/dist/use-session-monitor.js

@@ -0,0 +1,40 @@
+"use client";
+import { useEffect } from "react";
+import { startSessionMonitor } from "@eventuras/fides-auth-store";
+//#region src/use-session-monitor.ts
+/**
+* React hook for session monitoring with automatic cleanup
+*
+* @param store - The auth store to update
+* @param checkAuthStatus - Function to check authentication status
+* @param config - Optional configuration
+*
+* @example
+* ```typescript
+* import { useSessionMonitor } from '@eventuras/fides-auth-react';
+*
+* function App() {
+*   useSessionMonitor(authStore, checkAuthStatus, {
+*     interval: 30_000,
+*     onSessionExpired: () => {
+*       toast.warn('Your session has expired');
+*     }
+*   });
+*
+*   return <div>...</div>;
+* }
+* ```
+*/
+function useSessionMonitor(store, checkAuthStatus, config = {}) {
+	useEffect(() => {
+		return startSessionMonitor(store, checkAuthStatus, config);
+	}, [
+		store,
+		checkAuthStatus,
+		config
+	]);
+}
+//#endregion
+export { useSessionMonitor };
+
+//# sourceMappingURL=use-session-monitor.js.map

package/dist/use-session-monitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-session-monitor.js","names":[],"sources":["../src/use-session-monitor.ts"],"sourcesContent":["'use client';\n\nimport { useEffect } from 'react';\nimport {\n  startSessionMonitor,\n  type SessionMonitorConfig,\n  type AuthStatus,\n  type createAuthStore,\n} from '@eventuras/fides-auth-store';\n\n/**\n * React hook for session monitoring with automatic cleanup\n *\n * @param store - The auth store to update\n * @param checkAuthStatus - Function to check authentication status\n * @param config - Optional configuration\n *\n * @example\n * ```typescript\n * import { useSessionMonitor } from '@eventuras/fides-auth-react';\n *\n * function App() {\n *   useSessionMonitor(authStore, checkAuthStatus, {\n *     interval: 30_000,\n *     onSessionExpired: () => {\n *       toast.warn('Your session has expired');\n *     }\n *   });\n *\n *   return <div>...</div>;\n * }\n * ```\n */\nexport function useSessionMonitor(\n  store: ReturnType<typeof createAuthStore>,\n  checkAuthStatus: () => Promise<AuthStatus>,\n  config: SessionMonitorConfig = {}\n): void {\n  useEffect(() => {\n    return startSessionMonitor(store, checkAuthStatus, config);\n  }, [store, checkAuthStatus, config]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,kBACd,OACA,iBACA,SAA+B,CAAC,GAC1B;CACN,gBAAgB;EACd,OAAO,oBAAoB,OAAO,iBAAiB,MAAM;CAC3D,GAAG;EAAC;EAAO;EAAiB;CAAM,CAAC;AACrC"}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@eventuras/fides-auth-react",
+  "version": "0.1.0",
+  "description": "React hooks for @eventuras/fides-auth — auth store bindings, session monitoring, and heartbeat",
+  "keywords": [
+    "authentication",
+    "oauth",
+    "oidc",
+    "session",
+    "react",
+    "hooks",
+    "xstate"
+  ],
+  "homepage": "https://github.com/losol/fides-auth/tree/main/packages/fides-auth-react#readme",
+  "bugs": {
+    "url": "https://github.com/losol/fides-auth/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/losol/fides-auth.git",
+    "directory": "packages/fides-auth-react"
+  },
+  "license": "MIT",
+  "author": "losol <losol@users.noreply.github.com>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@eventuras/logger": "^0.8.1",
+    "@xstate/store-react": "^2.0.0",
+    "@eventuras/fides-auth": "0.9.0",
+    "@eventuras/fides-auth-store": "0.1.0"
+  },
+  "peerDependencies": {
+    "@xstate/store": "^4.0.0",
+    "@xstate/store-react": "^2.0.0",
+    "react": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.14",
+    "@xstate/store": "^4.0.0",
+    "@xstate/store-react": "^2.0.0",
+    "react": "^19.2.0",
+    "vite": "^8.0.8",
+    "vitest": "^4.1.6",
+    "@eventuras/typescript-config": "1.0.0",
+    "@eventuras/vite-config": "0.2.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}