@monocloud/auth-react 0.1.1-canary-20260605042109

package/dist/components/signup.mjs

@@ -0,0 +1,66 @@
+"use client";
+import { useAuth } from "../use-auth.mjs";
+import React from "react";
+//#region src/components/signup.tsx
+/**
+* `<SignUp>` renders a button that starts the sign-up (registration) flow when
+* clicked.
+*
+* @example Basic Usage
+*
+* ```tsx:src/SignUpButton.tsx tab="Basic Usage" tab-group="SignUp"
+* "use client";
+*
+* import { SignUp } from "@monocloud/auth-react";
+*
+* export default function Home() {
+*   return <SignUp>Create account</SignUp>;
+* }
+* ```
+*
+* @example Customized
+*
+* ```tsx:src/SignUpButton.tsx tab="Customized" tab-group="SignUp"
+* "use client";
+*
+* import { SignUp } from "@monocloud/auth-react";
+*
+* export default function Home() {
+*   return (
+*     <SignUp returnUrl="/welcome">
+*       Sign-up now
+*     </SignUp>
+*   );
+* }
+* ```
+*
+* @param props - Sign-up options.
+* @returns A button that triggers sign-up on click.
+*
+* @category Components
+*/
+const SignUp = ({ children, maxAge, uiLocales, mode, acrValues, display, resource, returnUrl, scopes, appState, ...props }) => {
+	const { signIn } = useAuth();
+	return /* @__PURE__ */ React.createElement("button", {
+		...props,
+		type: "button",
+		onClick: () => {
+			signIn({
+				signUp: true,
+				maxAge,
+				uiLocales,
+				mode,
+				acrValues,
+				display,
+				resource,
+				returnUrl,
+				scopes,
+				appState
+			});
+		}
+	}, children);
+};
+//#endregion
+export { SignUp };
+
+//# sourceMappingURL=signup.mjs.map

package/dist/components/signup.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signup.mjs","names":[],"sources":["../../src/components/signup.tsx"],"sourcesContent":["'use client';\n\nimport type { SignInOptions } from '@monocloud/auth-web-js';\nimport React from 'react';\nimport { useAuth } from '../use-auth';\n\n/**\n * Props for the `<SignUp />` component.\n *\n * @category Types\n */\nexport interface SignUpProps\n  extends\n    Omit<\n      SignInOptions,\n      'signUp' | 'authenticatorHint' | 'loginHint' | 'prompt'\n    >,\n    React.ButtonHTMLAttributes<HTMLButtonElement> {\n  /**\n   * Content rendered inside the button.\n   */\n  children: React.ReactNode;\n}\n\n/**\n * `<SignUp>` renders a button that starts the sign-up (registration) flow when\n * clicked.\n *\n * @example Basic Usage\n *\n * ```tsx:src/SignUpButton.tsx tab=\"Basic Usage\" tab-group=\"SignUp\"\n * \"use client\";\n *\n * import { SignUp } from \"@monocloud/auth-react\";\n *\n * export default function Home() {\n *   return <SignUp>Create account</SignUp>;\n * }\n * ```\n *\n * @example Customized\n *\n * ```tsx:src/SignUpButton.tsx tab=\"Customized\" tab-group=\"SignUp\"\n * \"use client\";\n *\n * import { SignUp } from \"@monocloud/auth-react\";\n *\n * export default function Home() {\n *   return (\n *     <SignUp returnUrl=\"/welcome\">\n *       Sign-up now\n *     </SignUp>\n *   );\n * }\n * ```\n *\n * @param props - Sign-up options.\n * @returns A button that triggers sign-up on click.\n *\n * @category Components\n */\nexport const SignUp = ({\n  children,\n  maxAge,\n  uiLocales,\n  mode,\n  acrValues,\n  display,\n  resource,\n  returnUrl,\n  scopes,\n  appState,\n  ...props\n}: SignUpProps): React.JSX.Element => {\n  const { signIn } = useAuth();\n\n  return (\n    <button\n      {...props}\n      type=\"button\"\n      onClick={() => {\n        void signIn({\n          signUp: true,\n          maxAge,\n          uiLocales,\n          mode,\n          acrValues,\n          display,\n          resource,\n          returnUrl,\n          scopes,\n          appState,\n        });\n      }}\n    >\n      {children}\n    </button>\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DA,MAAa,UAAU,EACrB,UACA,QACA,WACA,MACA,WACA,SACA,UACA,WACA,QACA,UACA,GAAG,YACiC;CACpC,MAAM,EAAE,WAAW,QAAQ;CAE3B,OACE,sBAAA,cAAC,UAAD;EACE,GAAI;EACJ,MAAK;EACL,eAAe;GACb,OAAY;IACV,QAAQ;IACR;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;GACF,CAAC;EACH;CAGM,GADL,QACK;AAEZ"}

package/dist/context.cjs

@@ -0,0 +1,12 @@
+"use client";
+let react = require("react");
+//#region src/context.ts
+const MonoCloudAuthContext = (0, react.createContext)(void 0);
+const MonoCloudClientContext = (0, react.createContext)(void 0);
+const MonoCloudProcessCallbackContext = (0, react.createContext)(void 0);
+//#endregion
+exports.MonoCloudAuthContext = MonoCloudAuthContext;
+exports.MonoCloudClientContext = MonoCloudClientContext;
+exports.MonoCloudProcessCallbackContext = MonoCloudProcessCallbackContext;
+
+//# sourceMappingURL=context.cjs.map

package/dist/context.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.cjs","names":[],"sources":["../src/context.ts"],"sourcesContent":["'use client';\n\nimport type { MonoCloudWebJSClient } from '@monocloud/auth-web-js';\nimport { createContext } from 'react';\nimport type { MonoCloudAuth } from './types';\n\nexport const MonoCloudAuthContext = createContext<MonoCloudAuth | undefined>(\n  undefined\n);\n\nexport const MonoCloudClientContext = createContext<\n  MonoCloudWebJSClient | undefined\n>(undefined);\n\nexport const MonoCloudProcessCallbackContext = createContext<\n  (() => Promise<void>) | undefined\n>(undefined);\n"],"mappings":";;;AAMA,MAAa,wBAAA,GAAA,MAAA,eACX,KAAA,CACF;AAEA,MAAa,0BAAA,GAAA,MAAA,eAEX,KAAA,CAAS;AAEX,MAAa,mCAAA,GAAA,MAAA,eAEX,KAAA,CAAS"}

package/dist/context.mjs

@@ -0,0 +1,10 @@
+"use client";
+import { createContext } from "react";
+//#region src/context.ts
+const MonoCloudAuthContext = createContext(void 0);
+const MonoCloudClientContext = createContext(void 0);
+const MonoCloudProcessCallbackContext = createContext(void 0);
+//#endregion
+export { MonoCloudAuthContext, MonoCloudClientContext, MonoCloudProcessCallbackContext };
+
+//# sourceMappingURL=context.mjs.map

package/dist/context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.mjs","names":[],"sources":["../src/context.ts"],"sourcesContent":["'use client';\n\nimport type { MonoCloudWebJSClient } from '@monocloud/auth-web-js';\nimport { createContext } from 'react';\nimport type { MonoCloudAuth } from './types';\n\nexport const MonoCloudAuthContext = createContext<MonoCloudAuth | undefined>(\n  undefined\n);\n\nexport const MonoCloudClientContext = createContext<\n  MonoCloudWebJSClient | undefined\n>(undefined);\n\nexport const MonoCloudProcessCallbackContext = createContext<\n  (() => Promise<void>) | undefined\n>(undefined);\n"],"mappings":";;;AAMA,MAAa,uBAAuB,cAClC,KAAA,CACF;AAEA,MAAa,yBAAyB,cAEpC,KAAA,CAAS;AAEX,MAAa,kCAAkC,cAE7C,KAAA,CAAS"}

package/dist/index.cjs

@@ -0,0 +1,79 @@
+"use client";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_monocloud_auth_provider = require("./monocloud-auth-provider.cjs");
+const require_use_auth = require("./use-auth.cjs");
+const require_use_monocloud_client = require("./use-monocloud-client.cjs");
+const require_protected = require("./components/protected.cjs");
+const require_process_callback = require("./components/process-callback.cjs");
+const require_signin = require("./components/signin.cjs");
+const require_signup = require("./components/signup.cjs");
+const require_signout = require("./components/signout.cjs");
+let _monocloud_auth_web_js = require("@monocloud/auth-web-js");
+Object.defineProperty(exports, "LocalStorage", {
+	enumerable: true,
+	get: function() {
+		return _monocloud_auth_web_js.LocalStorage;
+	}
+});
+Object.defineProperty(exports, "MemoryStorage", {
+	enumerable: true,
+	get: function() {
+		return _monocloud_auth_web_js.MemoryStorage;
+	}
+});
+Object.defineProperty(exports, "MonoCloudAuthBaseError", {
+	enumerable: true,
+	get: function() {
+		return _monocloud_auth_web_js.MonoCloudAuthBaseError;
+	}
+});
+exports.MonoCloudAuthProvider = require_monocloud_auth_provider.MonoCloudAuthProvider;
+Object.defineProperty(exports, "MonoCloudHttpError", {
+	enumerable: true,
+	get: function() {
+		return _monocloud_auth_web_js.MonoCloudHttpError;
+	}
+});
+Object.defineProperty(exports, "MonoCloudJsError", {
+	enumerable: true,
+	get: function() {
+		return _monocloud_auth_web_js.MonoCloudJsError;
+	}
+});
+Object.defineProperty(exports, "MonoCloudOPError", {
+	enumerable: true,
+	get: function() {
+		return _monocloud_auth_web_js.MonoCloudOPError;
+	}
+});
+Object.defineProperty(exports, "MonoCloudTokenError", {
+	enumerable: true,
+	get: function() {
+		return _monocloud_auth_web_js.MonoCloudTokenError;
+	}
+});
+Object.defineProperty(exports, "MonoCloudValidationError", {
+	enumerable: true,
+	get: function() {
+		return _monocloud_auth_web_js.MonoCloudValidationError;
+	}
+});
+Object.defineProperty(exports, "MonoCloudWebJSClient", {
+	enumerable: true,
+	get: function() {
+		return _monocloud_auth_web_js.MonoCloudWebJSClient;
+	}
+});
+exports.ProcessCallback = require_process_callback.ProcessCallback;
+exports.Protected = require_protected.Protected;
+Object.defineProperty(exports, "SessionStorage", {
+	enumerable: true,
+	get: function() {
+		return _monocloud_auth_web_js.SessionStorage;
+	}
+});
+exports.SignIn = require_signin.SignIn;
+exports.SignOut = require_signout.SignOut;
+exports.SignUp = require_signup.SignUp;
+exports.useAuth = require_use_auth.useAuth;
+exports.useMonoCloudClient = require_use_monocloud_client.useMonoCloudClient;

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+import { AuthState, MonoCloudAuth, MonoCloudAuthProviderProps, ProcessCallbackProps } from "./types.mjs";
+import { MonoCloudAuthProvider } from "./monocloud-auth-provider.mjs";
+import { useAuth } from "./use-auth.mjs";
+import { useMonoCloudClient } from "./use-monocloud-client.mjs";
+import { Protected, ProtectedComponentProps } from "./components/protected.mjs";
+import { ProcessCallback } from "./components/process-callback.mjs";
+import { SignIn, SignInProps } from "./components/signin.mjs";
+import { SignUp, SignUpProps } from "./components/signup.mjs";
+import { SignOut, SignOutProps } from "./components/signout.mjs";
+import { AccessToken, Address, ApplicationState, Authenticators, AuthorizationParams, CallbackState, ClientAuthMethod, CodeChallengeMethod, DefaultAuthParams, DisplayOptions, GetTokensOptions, Group, IStorage, IdTokenClaims, Indicator, InteractionMode, Jwk, LocalStorage, MemoryStorage, MonoCloudAuthBaseError, MonoCloudHttpError, MonoCloudJsError, MonoCloudOPError, MonoCloudSession, MonoCloudTokenError, MonoCloudTokens, MonoCloudUser, MonoCloudValidationError, MonoCloudWebJSClient, MonoCloudWebJSClientOptions, OnSessionCreating, PostCallback, Prompt, RefreshGrantOptions, RefreshOptions, ResponseModes, ResponseTypes, SecurityAlgorithms, SessionStorage, SignInOptions, SignInSilentOptions, SignOutOptions, UserinfoResponse } from "@monocloud/auth-web-js";
+export { type AccessToken, type Address, type ApplicationState, type AuthState, type Authenticators, type AuthorizationParams, type CallbackState, type ClientAuthMethod, type CodeChallengeMethod, type DefaultAuthParams, type DisplayOptions, type GetTokensOptions, type Group, type IStorage, type IdTokenClaims, type Indicator, type InteractionMode, type Jwk, LocalStorage, MemoryStorage, type MonoCloudAuth, MonoCloudAuthBaseError, MonoCloudAuthProvider, type MonoCloudAuthProviderProps, MonoCloudHttpError, MonoCloudJsError, MonoCloudOPError, type MonoCloudSession, MonoCloudTokenError, type MonoCloudTokens, type MonoCloudUser, MonoCloudValidationError, MonoCloudWebJSClient, type MonoCloudWebJSClientOptions, type OnSessionCreating, type PostCallback, ProcessCallback, type ProcessCallbackProps, type Prompt, Protected, type ProtectedComponentProps, type RefreshGrantOptions, type RefreshOptions, type ResponseModes, type ResponseTypes, type SecurityAlgorithms, SessionStorage, SignIn, type SignInOptions, type SignInProps, type SignInSilentOptions, SignOut, type SignOutOptions, type SignOutProps, SignUp, type SignUpProps, type UserinfoResponse, useAuth, useMonoCloudClient };

package/dist/index.mjs

@@ -0,0 +1,11 @@
+"use client";
+import { MonoCloudAuthProvider } from "./monocloud-auth-provider.mjs";
+import { useAuth } from "./use-auth.mjs";
+import { useMonoCloudClient } from "./use-monocloud-client.mjs";
+import { Protected } from "./components/protected.mjs";
+import { ProcessCallback } from "./components/process-callback.mjs";
+import { SignIn } from "./components/signin.mjs";
+import { SignUp } from "./components/signup.mjs";
+import { SignOut } from "./components/signout.mjs";
+import { LocalStorage, MemoryStorage, MonoCloudAuthBaseError, MonoCloudHttpError, MonoCloudJsError, MonoCloudOPError, MonoCloudTokenError, MonoCloudValidationError, MonoCloudWebJSClient, SessionStorage } from "@monocloud/auth-web-js";
+export { LocalStorage, MemoryStorage, MonoCloudAuthBaseError, MonoCloudAuthProvider, MonoCloudHttpError, MonoCloudJsError, MonoCloudOPError, MonoCloudTokenError, MonoCloudValidationError, MonoCloudWebJSClient, ProcessCallback, Protected, SessionStorage, SignIn, SignOut, SignUp, useAuth, useMonoCloudClient };

package/dist/monocloud-auth-provider.cjs

@@ -0,0 +1,181 @@
+"use client";
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_context = require("./context.cjs");
+let _monocloud_auth_web_js = require("@monocloud/auth-web-js");
+let react = require("react");
+react = require_runtime.__toESM(react);
+//#region src/monocloud-auth-provider.tsx
+const initialState = {
+	isLoading: true,
+	isAuthenticated: false
+};
+/**
+* `<MonoCloudAuthProvider>` initializes the MonoCloud JavaScript client and makes
+* the authentication state and actions available through {@link useAuth}.
+*
+* @example Basic setup
+*
+* ```tsx:src/main.tsx tab="Basic setup" tab-group="MonoCloudAuthProvider"
+* "use client";
+*
+* import { MonoCloudAuthProvider } from "@monocloud/auth-react";
+*
+* export default function Root() {
+*   return (
+*     <MonoCloudAuthProvider
+*       tenantDomain="https://your-tenant-domain"
+*       clientId="your-client-id"
+*     >
+*       <App />
+*     </MonoCloudAuthProvider>
+*   );
+* }
+* ```
+*
+* @example Client-side router navigation
+*
+* ```tsx:src/main.tsx tab="Client-side router navigation" tab-group="MonoCloudAuthProvider"
+* "use client";
+*
+* import { MonoCloudAuthProvider } from "@monocloud/auth-react";
+* import { useNavigate } from "react-router-dom";
+*
+* export default function Root() {
+*   const navigate = useNavigate();
+*
+*   return (
+*     <MonoCloudAuthProvider
+*       tenantDomain="https://your-tenant-domain"
+*       clientId="your-client-id"
+*       autoProcessCallback={false}
+*       postCallback={state => navigate(state.returnUrl ?? "/")}
+*     >
+*       <App />
+*     </MonoCloudAuthProvider>
+*   );
+* }
+* ```
+*
+* @param props - Props for configuring the provider and the underlying client.
+* @returns The provider element wrapping `children`.
+*
+* @category Components
+*/
+const MonoCloudAuthProvider = ({ children, autoProcessCallback = true, ...clientOptions }) => {
+	const [state, setState] = (0, react.useState)(initialState);
+	const [client] = (0, react.useState)(() => new _monocloud_auth_web_js.MonoCloudWebJSClient(clientOptions));
+	const syncSession = (0, react.useCallback)(async () => {
+		const session = await client.getSession();
+		setState({
+			isLoading: false,
+			isAuthenticated: !!session,
+			user: session === null || session === void 0 ? void 0 : session.user,
+			session,
+			error: void 0
+		});
+	}, [client]);
+	const processCallback = (0, react.useCallback)(async () => {
+		setState((prev) => ({
+			...prev,
+			isLoading: true
+		}));
+		try {
+			await client.processCallback();
+			await syncSession();
+		} catch (e) {
+			setState({
+				isLoading: false,
+				isAuthenticated: false,
+				user: void 0,
+				session: void 0,
+				error: e
+			});
+			throw e;
+		}
+	}, [client, syncSession]);
+	const initialized = (0, react.useRef)(false);
+	(0, react.useEffect)(() => {
+		/* v8 ignore start -- StrictMode double-invocation guard */
+		if (initialized.current) return;
+		/* v8 ignore stop */
+		initialized.current = true;
+		if (autoProcessCallback) processCallback().catch(() => {});
+		else syncSession();
+	}, [
+		autoProcessCallback,
+		processCallback,
+		syncSession
+	]);
+	const signIn = (0, react.useCallback)(async (signInOptions) => {
+		setState((prev) => ({
+			...prev,
+			isLoading: true
+		}));
+		try {
+			await client.signIn(signInOptions);
+			await syncSession();
+		} catch (e) {
+			setState((prev) => ({
+				...prev,
+				isLoading: false,
+				error: e
+			}));
+		}
+	}, [client, syncSession]);
+	const signOut = (0, react.useCallback)(async (signOutOptions) => {
+		setState((prev) => ({
+			...prev,
+			isLoading: true
+		}));
+		try {
+			await client.signOut(signOutOptions);
+			await syncSession();
+		} catch (e) {
+			setState((prev) => ({
+				...prev,
+				isLoading: false,
+				error: e
+			}));
+		}
+	}, [client, syncSession]);
+	const signInSilent = (0, react.useCallback)(async (signInSilentOptions) => {
+		const session = await client.signInSilent(signInSilentOptions);
+		await syncSession();
+		return session;
+	}, [client, syncSession]);
+	const refreshSession = (0, react.useCallback)(async (refreshOptions) => {
+		await client.refreshSession(refreshOptions);
+		await syncSession();
+	}, [client, syncSession]);
+	const refetchUserInfo = (0, react.useCallback)(async () => {
+		await client.refetchUserInfo();
+		await syncSession();
+	}, [client, syncSession]);
+	const getTokens = (0, react.useCallback)(async (options) => {
+		const tokens = await client.getTokens(options);
+		await syncSession();
+		return tokens;
+	}, [client, syncSession]);
+	const value = (0, react.useMemo)(() => ({
+		...state,
+		signIn,
+		signOut,
+		signInSilent,
+		refreshSession,
+		refetchUserInfo,
+		getTokens
+	}), [
+		state,
+		signIn,
+		signOut,
+		signInSilent,
+		refreshSession,
+		refetchUserInfo,
+		getTokens
+	]);
+	return /* @__PURE__ */ react.default.createElement(require_context.MonoCloudClientContext.Provider, { value: client }, /* @__PURE__ */ react.default.createElement(require_context.MonoCloudProcessCallbackContext.Provider, { value: processCallback }, /* @__PURE__ */ react.default.createElement(require_context.MonoCloudAuthContext.Provider, { value }, children)));
+};
+//#endregion
+exports.MonoCloudAuthProvider = MonoCloudAuthProvider;
+
+//# sourceMappingURL=monocloud-auth-provider.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"monocloud-auth-provider.cjs","names":["MonoCloudWebJSClient","MonoCloudClientContext","MonoCloudProcessCallbackContext","MonoCloudAuthContext"],"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/monocloud-auth-provider.d.mts

@@ -0,0 +1,64 @@
+import { MonoCloudAuthProviderProps } from "./types.mjs";
+import React from "react";
+
+//#region src/monocloud-auth-provider.d.ts
+/**
+ * `<MonoCloudAuthProvider>` initializes the MonoCloud JavaScript client and makes
+ * the authentication state and actions available through {@link useAuth}.
+ *
+ * @example Basic setup
+ *
+ * ```tsx:src/main.tsx tab="Basic setup" tab-group="MonoCloudAuthProvider"
+ * "use client";
+ *
+ * import { MonoCloudAuthProvider } from "@monocloud/auth-react";
+ *
+ * export default function Root() {
+ *   return (
+ *     <MonoCloudAuthProvider
+ *       tenantDomain="https://your-tenant-domain"
+ *       clientId="your-client-id"
+ *     >
+ *       <App />
+ *     </MonoCloudAuthProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @example Client-side router navigation
+ *
+ * ```tsx:src/main.tsx tab="Client-side router navigation" tab-group="MonoCloudAuthProvider"
+ * "use client";
+ *
+ * import { MonoCloudAuthProvider } from "@monocloud/auth-react";
+ * import { useNavigate } from "react-router-dom";
+ *
+ * export default function Root() {
+ *   const navigate = useNavigate();
+ *
+ *   return (
+ *     <MonoCloudAuthProvider
+ *       tenantDomain="https://your-tenant-domain"
+ *       clientId="your-client-id"
+ *       autoProcessCallback={false}
+ *       postCallback={state => navigate(state.returnUrl ?? "/")}
+ *     >
+ *       <App />
+ *     </MonoCloudAuthProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @param props - Props for configuring the provider and the underlying client.
+ * @returns The provider element wrapping `children`.
+ *
+ * @category Components
+ */
+declare const MonoCloudAuthProvider: ({
+  children,
+  autoProcessCallback,
+  ...clientOptions
+}: MonoCloudAuthProviderProps) => React.JSX.Element;
+//#endregion
+export { MonoCloudAuthProvider };
+//# sourceMappingURL=monocloud-auth-provider.d.mts.map

package/dist/monocloud-auth-provider.mjs

@@ -0,0 +1,179 @@
+"use client";
+import { MonoCloudAuthContext, MonoCloudClientContext, MonoCloudProcessCallbackContext } from "./context.mjs";
+import { MonoCloudWebJSClient } from "@monocloud/auth-web-js";
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+//#region src/monocloud-auth-provider.tsx
+const initialState = {
+	isLoading: true,
+	isAuthenticated: false
+};
+/**
+* `<MonoCloudAuthProvider>` initializes the MonoCloud JavaScript client and makes
+* the authentication state and actions available through {@link useAuth}.
+*
+* @example Basic setup
+*
+* ```tsx:src/main.tsx tab="Basic setup" tab-group="MonoCloudAuthProvider"
+* "use client";
+*
+* import { MonoCloudAuthProvider } from "@monocloud/auth-react";
+*
+* export default function Root() {
+*   return (
+*     <MonoCloudAuthProvider
+*       tenantDomain="https://your-tenant-domain"
+*       clientId="your-client-id"
+*     >
+*       <App />
+*     </MonoCloudAuthProvider>
+*   );
+* }
+* ```
+*
+* @example Client-side router navigation
+*
+* ```tsx:src/main.tsx tab="Client-side router navigation" tab-group="MonoCloudAuthProvider"
+* "use client";
+*
+* import { MonoCloudAuthProvider } from "@monocloud/auth-react";
+* import { useNavigate } from "react-router-dom";
+*
+* export default function Root() {
+*   const navigate = useNavigate();
+*
+*   return (
+*     <MonoCloudAuthProvider
+*       tenantDomain="https://your-tenant-domain"
+*       clientId="your-client-id"
+*       autoProcessCallback={false}
+*       postCallback={state => navigate(state.returnUrl ?? "/")}
+*     >
+*       <App />
+*     </MonoCloudAuthProvider>
+*   );
+* }
+* ```
+*
+* @param props - Props for configuring the provider and the underlying client.
+* @returns The provider element wrapping `children`.
+*
+* @category Components
+*/
+const MonoCloudAuthProvider = ({ children, autoProcessCallback = true, ...clientOptions }) => {
+	const [state, setState] = useState(initialState);
+	const [client] = useState(() => new MonoCloudWebJSClient(clientOptions));
+	const syncSession = useCallback(async () => {
+		const session = await client.getSession();
+		setState({
+			isLoading: false,
+			isAuthenticated: !!session,
+			user: session === null || session === void 0 ? void 0 : session.user,
+			session,
+			error: void 0
+		});
+	}, [client]);
+	const processCallback = useCallback(async () => {
+		setState((prev) => ({
+			...prev,
+			isLoading: true
+		}));
+		try {
+			await client.processCallback();
+			await syncSession();
+		} catch (e) {
+			setState({
+				isLoading: false,
+				isAuthenticated: false,
+				user: void 0,
+				session: void 0,
+				error: e
+			});
+			throw e;
+		}
+	}, [client, syncSession]);
+	const initialized = useRef(false);
+	useEffect(() => {
+		/* v8 ignore start -- StrictMode double-invocation guard */
+		if (initialized.current) return;
+		/* v8 ignore stop */
+		initialized.current = true;
+		if (autoProcessCallback) processCallback().catch(() => {});
+		else syncSession();
+	}, [
+		autoProcessCallback,
+		processCallback,
+		syncSession
+	]);
+	const signIn = useCallback(async (signInOptions) => {
+		setState((prev) => ({
+			...prev,
+			isLoading: true
+		}));
+		try {
+			await client.signIn(signInOptions);
+			await syncSession();
+		} catch (e) {
+			setState((prev) => ({
+				...prev,
+				isLoading: false,
+				error: e
+			}));
+		}
+	}, [client, syncSession]);
+	const signOut = useCallback(async (signOutOptions) => {
+		setState((prev) => ({
+			...prev,
+			isLoading: true
+		}));
+		try {
+			await client.signOut(signOutOptions);
+			await syncSession();
+		} catch (e) {
+			setState((prev) => ({
+				...prev,
+				isLoading: false,
+				error: e
+			}));
+		}
+	}, [client, syncSession]);
+	const signInSilent = useCallback(async (signInSilentOptions) => {
+		const session = await client.signInSilent(signInSilentOptions);
+		await syncSession();
+		return session;
+	}, [client, syncSession]);
+	const refreshSession = useCallback(async (refreshOptions) => {
+		await client.refreshSession(refreshOptions);
+		await syncSession();
+	}, [client, syncSession]);
+	const refetchUserInfo = useCallback(async () => {
+		await client.refetchUserInfo();
+		await syncSession();
+	}, [client, syncSession]);
+	const getTokens = useCallback(async (options) => {
+		const tokens = await client.getTokens(options);
+		await syncSession();
+		return tokens;
+	}, [client, syncSession]);
+	const value = useMemo(() => ({
+		...state,
+		signIn,
+		signOut,
+		signInSilent,
+		refreshSession,
+		refetchUserInfo,
+		getTokens
+	}), [
+		state,
+		signIn,
+		signOut,
+		signInSilent,
+		refreshSession,
+		refetchUserInfo,
+		getTokens
+	]);
+	return /* @__PURE__ */ React.createElement(MonoCloudClientContext.Provider, { value: client }, /* @__PURE__ */ React.createElement(MonoCloudProcessCallbackContext.Provider, { value: processCallback }, /* @__PURE__ */ React.createElement(MonoCloudAuthContext.Provider, { value }, children)));
+};
+//#endregion
+export { MonoCloudAuthProvider };
+
+//# sourceMappingURL=monocloud-auth-provider.mjs.map