@monocloud/auth-react 0.1.1-canary-20260605042109

package/dist/monocloud-auth-provider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"monocloud-auth-provider.mjs","names":[],"sources":["../src/monocloud-auth-provider.tsx"],"sourcesContent":["'use client';\n\nimport {\n  MonoCloudWebJSClient,\n  type GetTokensOptions,\n  type MonoCloudSession,\n  type MonoCloudTokens,\n  type RefreshOptions,\n  type SignInOptions,\n  type SignInSilentOptions,\n  type SignOutOptions,\n} from '@monocloud/auth-web-js';\nimport React, {\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\nimport {\n  MonoCloudAuthContext,\n  MonoCloudClientContext,\n  MonoCloudProcessCallbackContext,\n} from './context';\nimport type {\n  AuthState,\n  MonoCloudAuth,\n  MonoCloudAuthProviderProps,\n} from './types';\n\nconst initialState: AuthState = {\n  isLoading: true,\n  isAuthenticated: false,\n};\n\n/**\n * `<MonoCloudAuthProvider>` initializes the MonoCloud JavaScript client and makes\n * the authentication state and actions available through {@link useAuth}.\n *\n * @example Basic setup\n *\n * ```tsx:src/main.tsx tab=\"Basic setup\" tab-group=\"MonoCloudAuthProvider\"\n * \"use client\";\n *\n * import { MonoCloudAuthProvider } from \"@monocloud/auth-react\";\n *\n * export default function Root() {\n *   return (\n *     <MonoCloudAuthProvider\n *       tenantDomain=\"https://your-tenant-domain\"\n *       clientId=\"your-client-id\"\n *     >\n *       <App />\n *     </MonoCloudAuthProvider>\n *   );\n * }\n * ```\n *\n * @example Client-side router navigation\n *\n * ```tsx:src/main.tsx tab=\"Client-side router navigation\" tab-group=\"MonoCloudAuthProvider\"\n * \"use client\";\n *\n * import { MonoCloudAuthProvider } from \"@monocloud/auth-react\";\n * import { useNavigate } from \"react-router-dom\";\n *\n * export default function Root() {\n *   const navigate = useNavigate();\n *\n *   return (\n *     <MonoCloudAuthProvider\n *       tenantDomain=\"https://your-tenant-domain\"\n *       clientId=\"your-client-id\"\n *       autoProcessCallback={false}\n *       postCallback={state => navigate(state.returnUrl ?? \"/\")}\n *     >\n *       <App />\n *     </MonoCloudAuthProvider>\n *   );\n * }\n * ```\n *\n * @param props - Props for configuring the provider and the underlying client.\n * @returns The provider element wrapping `children`.\n *\n * @category Components\n */\nexport const MonoCloudAuthProvider = ({\n  children,\n  autoProcessCallback = true,\n  ...clientOptions\n}: MonoCloudAuthProviderProps): React.JSX.Element => {\n  const [state, setState] = useState<AuthState>(initialState);\n\n  const [client] = useState<MonoCloudWebJSClient>(\n    () => new MonoCloudWebJSClient(clientOptions)\n  );\n\n  const syncSession = useCallback(async (): Promise<void> => {\n    const session = await client.getSession();\n    setState({\n      isLoading: false,\n      isAuthenticated: !!session,\n      user: session?.user,\n      session,\n      error: undefined,\n    });\n  }, [client]);\n\n  const processCallback = useCallback(async (): Promise<void> => {\n    setState(prev => ({ ...prev, isLoading: true }));\n\n    try {\n      await client.processCallback();\n      await syncSession();\n    } catch (e) {\n      setState({\n        isLoading: false,\n        isAuthenticated: false,\n        user: undefined,\n        session: undefined,\n        error: e as Error,\n      });\n      throw e;\n    }\n  }, [client, syncSession]);\n\n  const initialized = useRef(false);\n  useEffect(() => {\n    /* v8 ignore start -- StrictMode double-invocation guard */\n    if (initialized.current) {\n      return;\n    }\n    /* v8 ignore stop */\n    initialized.current = true;\n\n    if (autoProcessCallback) {\n      processCallback().catch(() => {});\n    } else {\n      syncSession();\n    }\n  }, [autoProcessCallback, processCallback, syncSession]);\n\n  const signIn = useCallback(\n    async (signInOptions?: SignInOptions): Promise<void> => {\n      setState(prev => ({ ...prev, isLoading: true }));\n      try {\n        await client.signIn(signInOptions);\n        await syncSession();\n      } catch (e) {\n        setState(prev => ({ ...prev, isLoading: false, error: e as Error }));\n      }\n    },\n    [client, syncSession]\n  );\n\n  const signOut = useCallback(\n    async (signOutOptions?: SignOutOptions): Promise<void> => {\n      setState(prev => ({ ...prev, isLoading: true }));\n      try {\n        await client.signOut(signOutOptions);\n        await syncSession();\n      } catch (e) {\n        setState(prev => ({ ...prev, isLoading: false, error: e as Error }));\n      }\n    },\n    [client, syncSession]\n  );\n\n  const signInSilent = useCallback(\n    async (\n      signInSilentOptions?: SignInSilentOptions\n    ): Promise<MonoCloudSession> => {\n      const session = await client.signInSilent(signInSilentOptions);\n      await syncSession();\n      return session;\n    },\n    [client, syncSession]\n  );\n\n  const refreshSession = useCallback(\n    async (refreshOptions?: RefreshOptions): Promise<void> => {\n      await client.refreshSession(refreshOptions);\n      await syncSession();\n    },\n    [client, syncSession]\n  );\n\n  const refetchUserInfo = useCallback(async (): Promise<void> => {\n    await client.refetchUserInfo();\n    await syncSession();\n  }, [client, syncSession]);\n\n  const getTokens = useCallback(\n    async (options?: GetTokensOptions): Promise<MonoCloudTokens> => {\n      const tokens = await client.getTokens(options);\n      await syncSession();\n      return tokens;\n    },\n    [client, syncSession]\n  );\n\n  const value = useMemo<MonoCloudAuth>(\n    () => ({\n      ...state,\n      signIn,\n      signOut,\n      signInSilent,\n      refreshSession,\n      refetchUserInfo,\n      getTokens,\n    }),\n    [\n      state,\n      signIn,\n      signOut,\n      signInSilent,\n      refreshSession,\n      refetchUserInfo,\n      getTokens,\n    ]\n  );\n\n  return (\n    <MonoCloudClientContext.Provider value={client}>\n      <MonoCloudProcessCallbackContext.Provider value={processCallback}>\n        <MonoCloudAuthContext.Provider value={value}>\n          {children}\n        </MonoCloudAuthContext.Provider>\n      </MonoCloudProcessCallbackContext.Provider>\n    </MonoCloudClientContext.Provider>\n  );\n};\n"],"mappings":"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"}

package/dist/types.d.mts

@@ -0,0 +1,107 @@
+import { GetTokensOptions, MonoCloudSession, MonoCloudTokens, MonoCloudUser, MonoCloudWebJSClientOptions, RefreshOptions, SignInOptions, SignInSilentOptions, SignOutOptions } from "@monocloud/auth-web-js";
+import { ReactNode } from "react";
+
+//#region src/types.d.ts
+/**
+ * The current authentication state.
+ *
+ * @category Types
+ */
+interface AuthState {
+  /**
+   * Flag indicating if the authentication state is still loading.
+   */
+  isLoading: boolean;
+  /**
+   * Flag indicating if the user is authenticated.
+   */
+  isAuthenticated: boolean;
+  /**
+   * Error encountered during authentication, if any.
+   */
+  error?: Error;
+  /**
+   * The authenticated user's information, if available.
+   */
+  user?: MonoCloudUser;
+  /**
+   * The current session, including tokens and the user, if available.
+   */
+  session?: MonoCloudSession;
+}
+/**
+ * The current authentication state and the authentication actions.
+ *
+ * @category Types
+ */
+interface MonoCloudAuth extends AuthState {
+  /**
+   * Initiates the sign-in flow.
+   */
+  signIn: (signInOptions?: SignInOptions) => Promise<void>;
+  /**
+   * Initiates the sign-out flow.
+   */
+  signOut: (signOutOptions?: SignOutOptions) => Promise<void>;
+  /**
+   * Attempts to silently restore the session via a hidden iframe (`prompt=none`).
+   */
+  signInSilent: (signInSilentOptions?: SignInSilentOptions) => Promise<MonoCloudSession>;
+  /**
+   * Refreshes the current session using the Refresh Token Grant.
+   */
+  refreshSession: (refreshOptions?: RefreshOptions) => Promise<void>;
+  /**
+   * Refetches the user's profile from the UserInfo endpoint and updates the session.
+   */
+  refetchUserInfo: () => Promise<void>;
+  /**
+   * Retrieves the active tokens, refreshing them if they have expired.
+   */
+  getTokens: (options?: GetTokensOptions) => Promise<MonoCloudTokens>;
+}
+/**
+ * Props for `<MonoCloudAuthProvider />`.
+ *
+ * @category Types
+ */
+interface MonoCloudAuthProviderProps extends MonoCloudWebJSClientOptions {
+  /**
+   * The application tree that should have access to the authentication context.
+   */
+  children: ReactNode;
+  /**
+   * When `true` (the default), the provider processes the OIDC callback
+   * automatically when it mounts. Set it to `false` when you handle the callback
+   * yourself with `<ProcessCallback />` on a dedicated route.
+   *
+   * @defaultValue true
+   */
+  autoProcessCallback?: boolean;
+}
+/**
+ * Props for the `<ProcessCallback />` component.
+ *
+ * @category Types
+ */
+interface ProcessCallbackProps {
+  /**
+   * Content rendered while the callback is being processed.
+   *
+   * @defaultValue null
+   */
+  loading?: ReactNode;
+  /**
+   * Content rendered when callback processing fails.
+   */
+  error?: ReactNode | ((error: Error) => ReactNode);
+  /**
+   * Content rendered after the callback has been processed successfully.
+   *
+   * @defaultValue null
+   */
+  children?: ReactNode;
+}
+//#endregion
+export { AuthState, MonoCloudAuth, MonoCloudAuthProviderProps, ProcessCallbackProps };
+//# sourceMappingURL=types.d.mts.map

package/dist/use-auth.cjs

@@ -0,0 +1,63 @@
+"use client";
+const require_context = require("./context.cjs");
+let _monocloud_auth_web_js = require("@monocloud/auth-web-js");
+let react = require("react");
+//#region src/use-auth.tsx
+/**
+* `useAuth()` is a client-side hook that exposes the current authentication
+* state and actions provided by {@link MonoCloudAuthProvider}.
+*
+* @example Reading the authentication state
+*
+* ```tsx:src/Profile.tsx tab="Reading the authentication state" tab-group="useAuth"
+* "use client";
+*
+* import { useAuth } from "@monocloud/auth-react";
+*
+* export default function Home() {
+*   const { isLoading, isAuthenticated, user } = useAuth();
+*
+*   if (isLoading) {
+*     return <>Loading...</>;
+*   }
+*
+*   if (!isAuthenticated) {
+*     return <>Not signed in</>;
+*   }
+*
+*   return <>User Id: {user?.sub}</>;
+* }
+* ```
+*
+* @example Triggering actions
+*
+* ```tsx:src/Profile.tsx tab="Triggering actions" tab-group="useAuth"
+* "use client";
+*
+* import { useAuth } from "@monocloud/auth-react";
+*
+* export default function Account() {
+*   const { signOut, refetchUserInfo } = useAuth();
+*
+*   return (
+*     <>
+*       <button onClick={() => refetchUserInfo()}>Refresh profile</button>
+*       <button onClick={() => signOut()}>Sign out</button>
+*     </>
+*   );
+* }
+* ```
+*
+* @returns The current {@link MonoCloudAuth}.
+*
+* @category Hooks
+*/
+const useAuth = () => {
+	const context = (0, react.useContext)(require_context.MonoCloudAuthContext);
+	if (!context) throw new _monocloud_auth_web_js.MonoCloudJsError("useAuth() can only be used inside a <MonoCloudAuthProvider>...</MonoCloudAuthProvider>.");
+	return context;
+};
+//#endregion
+exports.useAuth = useAuth;
+
+//# sourceMappingURL=use-auth.cjs.map

package/dist/use-auth.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-auth.cjs","names":["MonoCloudAuthContext","MonoCloudJsError"],"sources":["../src/use-auth.tsx"],"sourcesContent":["'use client';\n\nimport { MonoCloudJsError } from '@monocloud/auth-web-js';\nimport { useContext } from 'react';\nimport { MonoCloudAuthContext } from './context';\nimport type { MonoCloudAuth } from './types';\nimport type { MonoCloudAuthProvider } from './monocloud-auth-provider';\n\n/**\n * `useAuth()` is a client-side hook that exposes the current authentication\n * state and actions provided by {@link MonoCloudAuthProvider}.\n *\n * @example Reading the authentication state\n *\n * ```tsx:src/Profile.tsx tab=\"Reading the authentication state\" tab-group=\"useAuth\"\n * \"use client\";\n *\n * import { useAuth } from \"@monocloud/auth-react\";\n *\n * export default function Home() {\n *   const { isLoading, isAuthenticated, user } = useAuth();\n *\n *   if (isLoading) {\n *     return <>Loading...</>;\n *   }\n *\n *   if (!isAuthenticated) {\n *     return <>Not signed in</>;\n *   }\n *\n *   return <>User Id: {user?.sub}</>;\n * }\n * ```\n *\n * @example Triggering actions\n *\n * ```tsx:src/Profile.tsx tab=\"Triggering actions\" tab-group=\"useAuth\"\n * \"use client\";\n *\n * import { useAuth } from \"@monocloud/auth-react\";\n *\n * export default function Account() {\n *   const { signOut, refetchUserInfo } = useAuth();\n *\n *   return (\n *     <>\n *       <button onClick={() => refetchUserInfo()}>Refresh profile</button>\n *       <button onClick={() => signOut()}>Sign out</button>\n *     </>\n *   );\n * }\n * ```\n *\n * @returns The current {@link MonoCloudAuth}.\n *\n * @category Hooks\n */\nexport const useAuth = (): MonoCloudAuth => {\n  const context = useContext(MonoCloudAuthContext);\n\n  if (!context) {\n    throw new MonoCloudJsError(\n      'useAuth() can only be used inside a <MonoCloudAuthProvider>...</MonoCloudAuthProvider>.'\n    );\n  }\n\n  return context;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,MAAa,gBAA+B;CAC1C,MAAM,WAAA,GAAA,MAAA,YAAqBA,gBAAAA,oBAAoB;CAE/C,IAAI,CAAC,SACH,MAAM,IAAIC,uBAAAA,iBACR,yFACF;CAGF,OAAO;AACT"}

package/dist/use-auth.d.mts

@@ -0,0 +1,56 @@
+import { MonoCloudAuth } from "./types.mjs";
+
+//#region src/use-auth.d.ts
+/**
+ * `useAuth()` is a client-side hook that exposes the current authentication
+ * state and actions provided by {@link MonoCloudAuthProvider}.
+ *
+ * @example Reading the authentication state
+ *
+ * ```tsx:src/Profile.tsx tab="Reading the authentication state" tab-group="useAuth"
+ * "use client";
+ *
+ * import { useAuth } from "@monocloud/auth-react";
+ *
+ * export default function Home() {
+ *   const { isLoading, isAuthenticated, user } = useAuth();
+ *
+ *   if (isLoading) {
+ *     return <>Loading...</>;
+ *   }
+ *
+ *   if (!isAuthenticated) {
+ *     return <>Not signed in</>;
+ *   }
+ *
+ *   return <>User Id: {user?.sub}</>;
+ * }
+ * ```
+ *
+ * @example Triggering actions
+ *
+ * ```tsx:src/Profile.tsx tab="Triggering actions" tab-group="useAuth"
+ * "use client";
+ *
+ * import { useAuth } from "@monocloud/auth-react";
+ *
+ * export default function Account() {
+ *   const { signOut, refetchUserInfo } = useAuth();
+ *
+ *   return (
+ *     <>
+ *       <button onClick={() => refetchUserInfo()}>Refresh profile</button>
+ *       <button onClick={() => signOut()}>Sign out</button>
+ *     </>
+ *   );
+ * }
+ * ```
+ *
+ * @returns The current {@link MonoCloudAuth}.
+ *
+ * @category Hooks
+ */
+declare const useAuth: () => MonoCloudAuth;
+//#endregion
+export { useAuth };
+//# sourceMappingURL=use-auth.d.mts.map

package/dist/use-auth.mjs

@@ -0,0 +1,63 @@
+"use client";
+import { MonoCloudAuthContext } from "./context.mjs";
+import { MonoCloudJsError } from "@monocloud/auth-web-js";
+import { useContext } from "react";
+//#region src/use-auth.tsx
+/**
+* `useAuth()` is a client-side hook that exposes the current authentication
+* state and actions provided by {@link MonoCloudAuthProvider}.
+*
+* @example Reading the authentication state
+*
+* ```tsx:src/Profile.tsx tab="Reading the authentication state" tab-group="useAuth"
+* "use client";
+*
+* import { useAuth } from "@monocloud/auth-react";
+*
+* export default function Home() {
+*   const { isLoading, isAuthenticated, user } = useAuth();
+*
+*   if (isLoading) {
+*     return <>Loading...</>;
+*   }
+*
+*   if (!isAuthenticated) {
+*     return <>Not signed in</>;
+*   }
+*
+*   return <>User Id: {user?.sub}</>;
+* }
+* ```
+*
+* @example Triggering actions
+*
+* ```tsx:src/Profile.tsx tab="Triggering actions" tab-group="useAuth"
+* "use client";
+*
+* import { useAuth } from "@monocloud/auth-react";
+*
+* export default function Account() {
+*   const { signOut, refetchUserInfo } = useAuth();
+*
+*   return (
+*     <>
+*       <button onClick={() => refetchUserInfo()}>Refresh profile</button>
+*       <button onClick={() => signOut()}>Sign out</button>
+*     </>
+*   );
+* }
+* ```
+*
+* @returns The current {@link MonoCloudAuth}.
+*
+* @category Hooks
+*/
+const useAuth = () => {
+	const context = useContext(MonoCloudAuthContext);
+	if (!context) throw new MonoCloudJsError("useAuth() can only be used inside a <MonoCloudAuthProvider>...</MonoCloudAuthProvider>.");
+	return context;
+};
+//#endregion
+export { useAuth };
+
+//# sourceMappingURL=use-auth.mjs.map

package/dist/use-auth.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-auth.mjs","names":[],"sources":["../src/use-auth.tsx"],"sourcesContent":["'use client';\n\nimport { MonoCloudJsError } from '@monocloud/auth-web-js';\nimport { useContext } from 'react';\nimport { MonoCloudAuthContext } from './context';\nimport type { MonoCloudAuth } from './types';\nimport type { MonoCloudAuthProvider } from './monocloud-auth-provider';\n\n/**\n * `useAuth()` is a client-side hook that exposes the current authentication\n * state and actions provided by {@link MonoCloudAuthProvider}.\n *\n * @example Reading the authentication state\n *\n * ```tsx:src/Profile.tsx tab=\"Reading the authentication state\" tab-group=\"useAuth\"\n * \"use client\";\n *\n * import { useAuth } from \"@monocloud/auth-react\";\n *\n * export default function Home() {\n *   const { isLoading, isAuthenticated, user } = useAuth();\n *\n *   if (isLoading) {\n *     return <>Loading...</>;\n *   }\n *\n *   if (!isAuthenticated) {\n *     return <>Not signed in</>;\n *   }\n *\n *   return <>User Id: {user?.sub}</>;\n * }\n * ```\n *\n * @example Triggering actions\n *\n * ```tsx:src/Profile.tsx tab=\"Triggering actions\" tab-group=\"useAuth\"\n * \"use client\";\n *\n * import { useAuth } from \"@monocloud/auth-react\";\n *\n * export default function Account() {\n *   const { signOut, refetchUserInfo } = useAuth();\n *\n *   return (\n *     <>\n *       <button onClick={() => refetchUserInfo()}>Refresh profile</button>\n *       <button onClick={() => signOut()}>Sign out</button>\n *     </>\n *   );\n * }\n * ```\n *\n * @returns The current {@link MonoCloudAuth}.\n *\n * @category Hooks\n */\nexport const useAuth = (): MonoCloudAuth => {\n  const context = useContext(MonoCloudAuthContext);\n\n  if (!context) {\n    throw new MonoCloudJsError(\n      'useAuth() can only be used inside a <MonoCloudAuthProvider>...</MonoCloudAuthProvider>.'\n    );\n  }\n\n  return context;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,MAAa,gBAA+B;CAC1C,MAAM,UAAU,WAAW,oBAAoB;CAE/C,IAAI,CAAC,SACH,MAAM,IAAI,iBACR,yFACF;CAGF,OAAO;AACT"}

package/dist/use-monocloud-client.cjs

@@ -0,0 +1,47 @@
+"use client";
+const require_context = require("./context.cjs");
+let _monocloud_auth_web_js = require("@monocloud/auth-web-js");
+let react = require("react");
+//#region src/use-monocloud-client.tsx
+/**
+* `useMonoCloudClient()` returns the underlying {@link MonoCloudWebJSClient} created by
+* {@link MonoCloudAuthProvider}.
+*
+* @remarks
+* This is intended for advanced, lower-level operations that
+* {@link useAuth} does not cover - for example token revocation via
+* `client.oidcClient`. Most applications only need {@link useAuth}.
+*
+* @example Revoking the access token
+*
+* ```tsx title="Revoking the access token"
+* "use client";
+*
+* import { useAuth, useMonoCloudClient } from "@monocloud/auth-react";
+*
+* export default function RevokeButton() {
+*   const { getTokens } = useAuth();
+*   const client = useMonoCloudClient();
+*
+*   const revoke = async () => {
+*     const tokens = await getTokens();
+*     await client.oidcClient.revokeToken(tokens.accessToken);
+*   };
+*
+*   return <button onClick={() => void revoke()}>Revoke</button>;
+* }
+* ```
+*
+* @returns The underlying {@link MonoCloudWebJSClient} instance.
+*
+* @category Hooks
+*/
+const useMonoCloudClient = () => {
+	const client = (0, react.useContext)(require_context.MonoCloudClientContext);
+	if (!client) throw new _monocloud_auth_web_js.MonoCloudJsError("useMonoCloudClient() can only be used inside a <MonoCloudAuthProvider>...</MonoCloudAuthProvider>.");
+	return client;
+};
+//#endregion
+exports.useMonoCloudClient = useMonoCloudClient;
+
+//# sourceMappingURL=use-monocloud-client.cjs.map

package/dist/use-monocloud-client.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-monocloud-client.cjs","names":["MonoCloudClientContext","MonoCloudJsError"],"sources":["../src/use-monocloud-client.tsx"],"sourcesContent":["'use client';\n\nimport { MonoCloudJsError } from '@monocloud/auth-web-js';\nimport type { MonoCloudWebJSClient } from '@monocloud/auth-web-js';\nimport { useContext } from 'react';\nimport { MonoCloudClientContext } from './context';\nimport type { MonoCloudAuthProvider } from './monocloud-auth-provider';\nimport type { useAuth } from './use-auth';\n\n/**\n * `useMonoCloudClient()` returns the underlying {@link MonoCloudWebJSClient} created by\n * {@link MonoCloudAuthProvider}.\n *\n * @remarks\n * This is intended for advanced, lower-level operations that\n * {@link useAuth} does not cover - for example token revocation via\n * `client.oidcClient`. Most applications only need {@link useAuth}.\n *\n * @example Revoking the access token\n *\n * ```tsx title=\"Revoking the access token\"\n * \"use client\";\n *\n * import { useAuth, useMonoCloudClient } from \"@monocloud/auth-react\";\n *\n * export default function RevokeButton() {\n *   const { getTokens } = useAuth();\n *   const client = useMonoCloudClient();\n *\n *   const revoke = async () => {\n *     const tokens = await getTokens();\n *     await client.oidcClient.revokeToken(tokens.accessToken);\n *   };\n *\n *   return <button onClick={() => void revoke()}>Revoke</button>;\n * }\n * ```\n *\n * @returns The underlying {@link MonoCloudWebJSClient} instance.\n *\n * @category Hooks\n */\nexport const useMonoCloudClient = (): MonoCloudWebJSClient => {\n  const client = useContext(MonoCloudClientContext);\n\n  if (!client) {\n    throw new MonoCloudJsError(\n      'useMonoCloudClient() can only be used inside a <MonoCloudAuthProvider>...</MonoCloudAuthProvider>.'\n    );\n  }\n\n  return client;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,MAAa,2BAAiD;CAC5D,MAAM,UAAA,GAAA,MAAA,YAAoBA,gBAAAA,sBAAsB;CAEhD,IAAI,CAAC,QACH,MAAM,IAAIC,uBAAAA,iBACR,oGACF;CAGF,OAAO;AACT"}

package/dist/use-monocloud-client.d.mts

@@ -0,0 +1,40 @@
+import { MonoCloudWebJSClient } from "@monocloud/auth-web-js";
+
+//#region src/use-monocloud-client.d.ts
+/**
+ * `useMonoCloudClient()` returns the underlying {@link MonoCloudWebJSClient} created by
+ * {@link MonoCloudAuthProvider}.
+ *
+ * @remarks
+ * This is intended for advanced, lower-level operations that
+ * {@link useAuth} does not cover - for example token revocation via
+ * `client.oidcClient`. Most applications only need {@link useAuth}.
+ *
+ * @example Revoking the access token
+ *
+ * ```tsx title="Revoking the access token"
+ * "use client";
+ *
+ * import { useAuth, useMonoCloudClient } from "@monocloud/auth-react";
+ *
+ * export default function RevokeButton() {
+ *   const { getTokens } = useAuth();
+ *   const client = useMonoCloudClient();
+ *
+ *   const revoke = async () => {
+ *     const tokens = await getTokens();
+ *     await client.oidcClient.revokeToken(tokens.accessToken);
+ *   };
+ *
+ *   return <button onClick={() => void revoke()}>Revoke</button>;
+ * }
+ * ```
+ *
+ * @returns The underlying {@link MonoCloudWebJSClient} instance.
+ *
+ * @category Hooks
+ */
+declare const useMonoCloudClient: () => MonoCloudWebJSClient;
+//#endregion
+export { useMonoCloudClient };
+//# sourceMappingURL=use-monocloud-client.d.mts.map

package/dist/use-monocloud-client.mjs

@@ -0,0 +1,47 @@
+"use client";
+import { MonoCloudClientContext } from "./context.mjs";
+import { MonoCloudJsError } from "@monocloud/auth-web-js";
+import { useContext } from "react";
+//#region src/use-monocloud-client.tsx
+/**
+* `useMonoCloudClient()` returns the underlying {@link MonoCloudWebJSClient} created by
+* {@link MonoCloudAuthProvider}.
+*
+* @remarks
+* This is intended for advanced, lower-level operations that
+* {@link useAuth} does not cover - for example token revocation via
+* `client.oidcClient`. Most applications only need {@link useAuth}.
+*
+* @example Revoking the access token
+*
+* ```tsx title="Revoking the access token"
+* "use client";
+*
+* import { useAuth, useMonoCloudClient } from "@monocloud/auth-react";
+*
+* export default function RevokeButton() {
+*   const { getTokens } = useAuth();
+*   const client = useMonoCloudClient();
+*
+*   const revoke = async () => {
+*     const tokens = await getTokens();
+*     await client.oidcClient.revokeToken(tokens.accessToken);
+*   };
+*
+*   return <button onClick={() => void revoke()}>Revoke</button>;
+* }
+* ```
+*
+* @returns The underlying {@link MonoCloudWebJSClient} instance.
+*
+* @category Hooks
+*/
+const useMonoCloudClient = () => {
+	const client = useContext(MonoCloudClientContext);
+	if (!client) throw new MonoCloudJsError("useMonoCloudClient() can only be used inside a <MonoCloudAuthProvider>...</MonoCloudAuthProvider>.");
+	return client;
+};
+//#endregion
+export { useMonoCloudClient };
+
+//# sourceMappingURL=use-monocloud-client.mjs.map

package/dist/use-monocloud-client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-monocloud-client.mjs","names":[],"sources":["../src/use-monocloud-client.tsx"],"sourcesContent":["'use client';\n\nimport { MonoCloudJsError } from '@monocloud/auth-web-js';\nimport type { MonoCloudWebJSClient } from '@monocloud/auth-web-js';\nimport { useContext } from 'react';\nimport { MonoCloudClientContext } from './context';\nimport type { MonoCloudAuthProvider } from './monocloud-auth-provider';\nimport type { useAuth } from './use-auth';\n\n/**\n * `useMonoCloudClient()` returns the underlying {@link MonoCloudWebJSClient} created by\n * {@link MonoCloudAuthProvider}.\n *\n * @remarks\n * This is intended for advanced, lower-level operations that\n * {@link useAuth} does not cover - for example token revocation via\n * `client.oidcClient`. Most applications only need {@link useAuth}.\n *\n * @example Revoking the access token\n *\n * ```tsx title=\"Revoking the access token\"\n * \"use client\";\n *\n * import { useAuth, useMonoCloudClient } from \"@monocloud/auth-react\";\n *\n * export default function RevokeButton() {\n *   const { getTokens } = useAuth();\n *   const client = useMonoCloudClient();\n *\n *   const revoke = async () => {\n *     const tokens = await getTokens();\n *     await client.oidcClient.revokeToken(tokens.accessToken);\n *   };\n *\n *   return <button onClick={() => void revoke()}>Revoke</button>;\n * }\n * ```\n *\n * @returns The underlying {@link MonoCloudWebJSClient} instance.\n *\n * @category Hooks\n */\nexport const useMonoCloudClient = (): MonoCloudWebJSClient => {\n  const client = useContext(MonoCloudClientContext);\n\n  if (!client) {\n    throw new MonoCloudJsError(\n      'useMonoCloudClient() can only be used inside a <MonoCloudAuthProvider>...</MonoCloudAuthProvider>.'\n    );\n  }\n\n  return client;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,MAAa,2BAAiD;CAC5D,MAAM,SAAS,WAAW,sBAAsB;CAEhD,IAAI,CAAC,QACH,MAAM,IAAI,iBACR,oGACF;CAGF,OAAO;AACT"}

package/dist/use-process-callback.cjs

@@ -0,0 +1,14 @@
+"use client";
+const require_context = require("./context.cjs");
+let _monocloud_auth_web_js = require("@monocloud/auth-web-js");
+let react = require("react");
+//#region src/use-process-callback.tsx
+const useProcessCallback = () => {
+	const processCallback = (0, react.useContext)(require_context.MonoCloudProcessCallbackContext);
+	if (!processCallback) throw new _monocloud_auth_web_js.MonoCloudJsError("<ProcessCallback /> can only be used inside a <MonoCloudAuthProvider>...</MonoCloudAuthProvider>.");
+	return processCallback;
+};
+//#endregion
+exports.useProcessCallback = useProcessCallback;
+
+//# sourceMappingURL=use-process-callback.cjs.map

package/dist/use-process-callback.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-process-callback.cjs","names":["MonoCloudProcessCallbackContext","MonoCloudJsError"],"sources":["../src/use-process-callback.tsx"],"sourcesContent":["'use client';\n\nimport { MonoCloudJsError } from '@monocloud/auth-web-js';\nimport { useContext } from 'react';\nimport { MonoCloudProcessCallbackContext } from './context';\n\nexport const useProcessCallback = (): (() => Promise<void>) => {\n  const processCallback = useContext(MonoCloudProcessCallbackContext);\n\n  if (!processCallback) {\n    throw new MonoCloudJsError(\n      '<ProcessCallback /> can only be used inside a <MonoCloudAuthProvider>...</MonoCloudAuthProvider>.'\n    );\n  }\n\n  return processCallback;\n};\n"],"mappings":";;;;;AAMA,MAAa,2BAAkD;CAC7D,MAAM,mBAAA,GAAA,MAAA,YAA6BA,gBAAAA,+BAA+B;CAElE,IAAI,CAAC,iBACH,MAAM,IAAIC,uBAAAA,iBACR,mGACF;CAGF,OAAO;AACT"}

package/dist/use-process-callback.mjs

@@ -0,0 +1,14 @@
+"use client";
+import { MonoCloudProcessCallbackContext } from "./context.mjs";
+import { MonoCloudJsError } from "@monocloud/auth-web-js";
+import { useContext } from "react";
+//#region src/use-process-callback.tsx
+const useProcessCallback = () => {
+	const processCallback = useContext(MonoCloudProcessCallbackContext);
+	if (!processCallback) throw new MonoCloudJsError("<ProcessCallback /> can only be used inside a <MonoCloudAuthProvider>...</MonoCloudAuthProvider>.");
+	return processCallback;
+};
+//#endregion
+export { useProcessCallback };
+
+//# sourceMappingURL=use-process-callback.mjs.map

package/dist/use-process-callback.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-process-callback.mjs","names":[],"sources":["../src/use-process-callback.tsx"],"sourcesContent":["'use client';\n\nimport { MonoCloudJsError } from '@monocloud/auth-web-js';\nimport { useContext } from 'react';\nimport { MonoCloudProcessCallbackContext } from './context';\n\nexport const useProcessCallback = (): (() => Promise<void>) => {\n  const processCallback = useContext(MonoCloudProcessCallbackContext);\n\n  if (!processCallback) {\n    throw new MonoCloudJsError(\n      '<ProcessCallback /> can only be used inside a <MonoCloudAuthProvider>...</MonoCloudAuthProvider>.'\n    );\n  }\n\n  return processCallback;\n};\n"],"mappings":";;;;;AAMA,MAAa,2BAAkD;CAC7D,MAAM,kBAAkB,WAAW,+BAA+B;CAElE,IAAI,CAAC,iBACH,MAAM,IAAI,iBACR,mGACF;CAGF,OAAO;AACT"}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@monocloud/auth-react",
+  "version": "0.1.1-canary-20260605042109",
+  "description": "MonoCloud React Authentication SDK",
+  "keywords": [
+    "monocloud",
+    "authentication",
+    "auth",
+    "sdk",
+    "react",
+    "spa",
+    "browser"
+  ],
+  "homepage": "https://www.monocloud.com",
+  "bugs": {
+    "url": "https://github.com/monocloud/auth-js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/monocloud/auth-js.git",
+    "directory": "packages/react"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "MonoCloud",
+    "email": "support@monocloud.com"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "dependencies": {
+    "@monocloud/auth-web-js": "0.1.2"
+  },
+  "devDependencies": {
+    "@testing-library/dom": "10.4.1",
+    "@testing-library/react": "16.3.2",
+    "@types/react": "19.2.15",
+    "@types/react-dom": "19.2.3",
+    "eslint": "10.4.0",
+    "@monocloud/auth-test-utils": "0.0.1"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.2.3",
+    "react-dom": "^18.3.1 || ^19.2.3"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "lint:es": "eslint src tests",
+    "lint:ts": "tsc",
+    "lint": "pnpm run lint:es && pnpm run lint:ts",
+    "test": "eslint tests && rimraf coverage && vitest && pnpm report",
+    "report": "nyc report --reporter json-summary --reporter html --reporter text -t ./coverage --report-dir ./coverage/summary && npx @monocloud/auth-test-utils check-coverage"
+  }
+}