@replanejs/react 0.8.20 → 0.9.0

package/README.md

@@ -75,27 +75,32 @@ import { ErrorBoundary } from "react-error-boundary";
 
 #### Client Options
 
-The `options` prop accepts all options from `@replanejs/sdk`. Key options:
-
-| Option                    | Type                   | Required | Description                                |
-| ------------------------- | ---------------------- | -------- | ------------------------------------------ |
-| `baseUrl`                 | `string`               | Yes      | Replane server URL                         |
-| `sdkKey`                  | `string`               | Yes      | SDK key for authentication                 |
-| `context`                 | `Record<string, any>`  | No       | Default context for override evaluations   |
-| `defaults`                | `Record<string, any>`  | No       | Default values if server is unavailable    |
-| `required`                | `string[]` or `object` | No       | Configs that must exist for initialization |
-| `initializationTimeoutMs` | `number`               | No       | SDK initialization timeout (default: 5000) |
-
-See [`@replanejs/sdk` documentation](https://github.com/replane-dev/replane-javascript/tree/main/packages/sdk#options) for the complete list of options.
+The `options` prop accepts the following options:
+
+| Option               | Type                  | Required | Description                                  |
+| -------------------- | --------------------- | -------- | -------------------------------------------- |
+| `baseUrl`            | `string`              | Yes      | Replane server URL                           |
+| `sdkKey`             | `string`              | Yes      | SDK key for authentication                   |
+| `context`            | `Record<string, any>` | No       | Default context for override evaluations     |
+| `defaults`           | `Record<string, any>` | No       | Default values if server is unavailable      |
+| `connectTimeoutMs`   | `number`              | No       | SDK connection timeout (default: 5000)       |
+| `requestTimeoutMs`   | `number`              | No       | Timeout for SSE requests (default: 2000)     |
+| `retryDelayMs`       | `number`              | No       | Base delay between retries (default: 200)    |
+| `inactivityTimeoutMs`| `number`              | No       | SSE inactivity timeout (default: 30000)      |
+| `fetchFn`            | `typeof fetch`        | No       | Custom fetch implementation                  |
+| `logger`             | `ReplaneLogger`       | No       | Custom logger (default: console)             |
+
+See [`@replanejs/sdk` documentation](https://github.com/replane-dev/replane-javascript/tree/main/packages/sdk#api) for more details.
 
 #### 2. With pre-created client
 
 Use this when you need more control over client lifecycle:
 
 ```tsx
-import { createReplaneClient } from "@replanejs/sdk";
+import { Replane } from "@replanejs/sdk";
 
-const client = await createReplaneClient({
+const client = new Replane();
+await client.connect({
   baseUrl: "https://your-replane-server.com",
   sdkKey: "your-sdk-key",
 });
@@ -131,26 +136,24 @@ Restore a client from a snapshot obtained on the server. This is synchronous and
 
 ```tsx
 // On the server
-const serverClient = await createReplaneClient({ baseUrl: "...", sdkKey: "..." });
+const serverClient = new Replane();
+await serverClient.connect({ baseUrl: "...", sdkKey: "..." });
 const snapshot = serverClient.getSnapshot();
 // Pass snapshot to client via props, context, or serialized HTML
 
 // On the client
 <ReplaneProvider
-  restoreOptions={{
-    snapshot,
-    // Optional: connect for live updates
-    connection: {
-      baseUrl: "https://your-replane-server.com",
-      sdkKey: "your-sdk-key",
-    },
+  options={{
+    baseUrl: "https://your-replane-server.com",
+    sdkKey: "your-sdk-key",
   }}
+  snapshot={snapshot}
 >
   <App />
 </ReplaneProvider>;
 ```
 
-The restored client is immediately available with no loading state. If `connection` is provided, it will establish a connection for real-time updates in the background.
+The restored client is immediately available with no loading state. The provider will establish a connection for real-time updates in the background.
 
 ### useConfig
 

package/dist/index.cjs

@@ -33,7 +33,7 @@ const ReplaneContext = (0, react.createContext)(null);
 
 //#endregion
 //#region src/version.ts
-const VERSION = "0.8.20";
+const VERSION = "0.9.0";
 const DEFAULT_AGENT = `replane-js-react/${VERSION}`;
 
 //#endregion
@@ -43,7 +43,28 @@ function getCacheKey(options) {
 	return `${options.baseUrl}:${options.sdkKey}`;
 }
 /**
-* Hook to manage ReplaneClient creation internally.
+* Creates a Replane client and connects it.
+*/
+async function createAndConnectClient(options) {
+	const client = new __replanejs_sdk.Replane({
+		logger: options.logger,
+		context: options.context,
+		defaults: options.defaults
+	});
+	await client.connect({
+		baseUrl: options.baseUrl,
+		sdkKey: options.sdkKey,
+		connectTimeoutMs: options.connectTimeoutMs,
+		retryDelayMs: options.retryDelayMs,
+		requestTimeoutMs: options.requestTimeoutMs,
+		inactivityTimeoutMs: options.inactivityTimeoutMs,
+		fetchFn: options.fetchFn,
+		agent: options.agent ?? DEFAULT_AGENT
+	});
+	return client;
+}
+/**
+* Hook to manage Replane client creation internally.
 * Handles loading state and cleanup.
 */
 function useReplaneClientInternal(options) {
@@ -58,12 +79,9 @@ function useReplaneClientInternal(options) {
 		let cancelled = false;
 		async function initClient() {
 			try {
-				const client = await (0, __replanejs_sdk.createReplaneClient)({
-					...optionsRef.current,
-					agent: optionsRef.current.agent ?? DEFAULT_AGENT
-				});
+				const client = await createAndConnectClient(optionsRef.current);
 				if (cancelled) {
-					client.close();
+					client.disconnect();
 					return;
 				}
 				clientRef.current = client;
@@ -86,7 +104,7 @@ function useReplaneClientInternal(options) {
 		return () => {
 			cancelled = true;
 			if (clientRef.current) {
-				clientRef.current.close();
+				clientRef.current.disconnect();
 				clientRef.current = null;
 			}
 		};
@@ -105,10 +123,7 @@ function useReplaneClientSuspense(options) {
 		if (cached.result) return cached.result;
 		throw cached.promise;
 	}
-	const promise = (0, __replanejs_sdk.createReplaneClient)({
-		...options,
-		agent: options.agent ?? DEFAULT_AGENT
-	}).then((client) => {
+	const promise = createAndConnectClient(options).then((client) => {
 		const entry = suspenseCache.get(cacheKey);
 		if (entry) entry.result = client;
 		return client;
@@ -129,101 +144,6 @@ function clearSuspenseCache(options) {
 	else suspenseCache.clear();
 }
 
-//#endregion
-//#region src/hooks.ts
-function useReplane() {
-	const context = (0, react.useContext)(ReplaneContext);
-	if (!context) throw new Error("useReplane must be used within a ReplaneProvider");
-	return context.client;
-}
-function useConfig(name, options) {
-	const client = useReplane();
-	const subscribe = (0, react.useCallback)((callback) => {
-		return client.subscribe(name, callback);
-	}, [client, name]);
-	const get = (0, react.useCallback)(() => {
-		return client.get(name, options);
-	}, [
-		client,
-		name,
-		options
-	]);
-	const value = (0, react.useSyncExternalStore)(subscribe, get, get);
-	return value;
-}
-/**
-* Creates a typed version of useReplane hook.
-*
-* @example
-* ```tsx
-* interface AppConfigs {
-*   theme: { darkMode: boolean };
-*   features: { beta: boolean };
-* }
-*
-* const useAppReplane = createReplaneHook<AppConfigs>();
-*
-* function MyComponent() {
-*   const replane = useAppReplane();
-*   // replane.get("theme") returns { darkMode: boolean }
-* }
-* ```
-*/
-function createReplaneHook() {
-	return function useTypedReplane() {
-		return useReplane();
-	};
-}
-/**
-* Creates a typed version of useConfig hook.
-*
-* @example
-* ```tsx
-* interface AppConfigs {
-*   theme: { darkMode: boolean };
-*   features: { beta: boolean };
-* }
-*
-* const useAppConfig = createConfigHook<AppConfigs>();
-*
-* function MyComponent() {
-*   const theme = useAppConfig("theme");
-*   // theme is typed as { darkMode: boolean }
-* }
-* ```
-*/
-function createConfigHook() {
-	return function useTypedConfig(name, options) {
-		return useConfig(String(name), options);
-	};
-}
-/**
-* Hook for creating stateful resources with cleanup support.
-* Unlike useMemo, this guarantees cleanup when dependencies change or on unmount.
-*
-* @param factory - Function that creates the resource
-* @param cleanup - Function that cleans up the resource
-* @param deps - Dependencies array (resource is recreated when these change)
-*/
-function useStateful(factory, cleanup, deps) {
-	const valueRef = (0, react.useRef)(null);
-	const initializedRef = (0, react.useRef)(false);
-	if (!initializedRef.current) {
-		valueRef.current = factory();
-		initializedRef.current = true;
-	}
-	(0, react.useEffect)(() => {
-		if (valueRef.current === null) valueRef.current = factory();
-		return () => {
-			if (valueRef.current !== null) {
-				cleanup(valueRef.current);
-				valueRef.current = null;
-			}
-		};
-	}, deps);
-	return valueRef.current;
-}
-
 //#endregion
 //#region src/types.ts
 /**
@@ -239,7 +159,7 @@ function hasClient(props) {
 * Internal provider component for pre-created client.
 */
 function ReplaneProviderWithClient({ client, children }) {
-	const value = (0, react.useMemo)(() => ({ client }), [client]);
+	const value = (0, react.useMemo)(() => ({ replane: client }), [client]);
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReplaneContext.Provider, {
 		value,
 		children
@@ -247,24 +167,44 @@ function ReplaneProviderWithClient({ client, children }) {
 }
 /**
 * Internal provider component for restoring client from snapshot.
-* Uses restoreReplaneClient which is synchronous.
+* Creates a Replane client synchronously and connects in background.
 */
 function ReplaneProviderWithSnapshot({ options, snapshot, children }) {
-	const client = useStateful(() => (0, __replanejs_sdk.restoreReplaneClient)({
+	const replaneRef = (0, react.useRef)(void 0);
+	if (!replaneRef.current) replaneRef.current = new __replanejs_sdk.Replane({
 		snapshot,
-		connection: {
+		logger: options.logger,
+		context: options.context,
+		defaults: options.defaults
+	});
+	(0, react.useEffect)(() => {
+		replaneRef.current.connect({
 			baseUrl: options.baseUrl,
 			sdkKey: options.sdkKey,
-			fetchFn: options.fetchFn,
-			requestTimeoutMs: options.requestTimeoutMs,
+			connectTimeoutMs: options.connectTimeoutMs,
 			retryDelayMs: options.retryDelayMs,
+			requestTimeoutMs: options.requestTimeoutMs,
 			inactivityTimeoutMs: options.inactivityTimeoutMs,
-			logger: options.logger,
+			fetchFn: options.fetchFn,
 			agent: options.agent ?? DEFAULT_AGENT
-		},
-		context: options.context
-	}), (c) => c.close(), [snapshot, options]);
-	const value = (0, react.useMemo)(() => ({ client }), [client]);
+		}).catch((err) => {
+			(options.logger ?? console)?.error("Failed to connect Replane client", err);
+		});
+		return () => {
+			replaneRef.current.disconnect();
+		};
+	}, [
+		options.agent,
+		options.baseUrl,
+		options.connectTimeoutMs,
+		options.fetchFn,
+		options.inactivityTimeoutMs,
+		options.logger,
+		options.requestTimeoutMs,
+		options.retryDelayMs,
+		options.sdkKey
+	]);
+	const value = (0, react.useMemo)(() => ({ replane: replaneRef.current }), []);
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReplaneContext.Provider, {
 		value,
 		children
@@ -278,7 +218,7 @@ function ReplaneProviderWithOptions({ options, children, loader }) {
 	const state = useReplaneClientInternal(options);
 	if (state.status === "loading") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: loader ?? null });
 	if (state.status === "error") throw state.error;
-	const value = { client: state.client };
+	const value = { replane: state.client };
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReplaneContext.Provider, {
 		value,
 		children
@@ -289,20 +229,21 @@ function ReplaneProviderWithOptions({ options, children, loader }) {
 */
 function ReplaneProviderWithSuspense({ options, children }) {
 	const client = useReplaneClientSuspense(options);
-	const value = (0, react.useMemo)(() => ({ client }), [client]);
+	const value = (0, react.useMemo)(() => ({ replane: client }), [client]);
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReplaneContext.Provider, {
 		value,
 		children
 	});
 }
 /**
-* Provider component that makes a ReplaneClient available to the component tree.
+* Provider component that makes a Replane client available to the component tree.
 *
-* Can be used in three ways:
+* Can be used in several ways:
 *
 * 1. With a pre-created client:
 * ```tsx
-* const client = await createReplaneClient({ ... });
+* const client = new Replane({ defaults: { ... } });
+* await client.connect({ baseUrl: '...', sdkKey: '...' });
 * <ReplaneProvider client={client}>
 *   <App />
 * </ReplaneProvider>
@@ -362,6 +303,93 @@ function ReplaneProvider(props) {
 }
 
 //#endregion
+//#region src/hooks.ts
+function useReplane() {
+	const context = (0, react.useContext)(ReplaneContext);
+	if (!context) throw new Error("useReplane must be used within a ReplaneProvider");
+	return context.replane;
+}
+function useConfig(name, options) {
+	const client = useReplane();
+	const subscribe = (0, react.useCallback)((callback) => {
+		return client.subscribe(name, callback);
+	}, [client, name]);
+	const get = (0, react.useCallback)(() => {
+		return client.get(name, options);
+	}, [
+		client,
+		name,
+		options
+	]);
+	const value = (0, react.useSyncExternalStore)(subscribe, get, get);
+	return value;
+}
+/**
+* Creates a typed version of useReplane hook.
+*
+* @example
+* ```tsx
+* interface AppConfigs {
+*   theme: { darkMode: boolean };
+*   features: { beta: boolean };
+* }
+*
+* const useAppReplane = createReplaneHook<AppConfigs>();
+*
+* function MyComponent() {
+*   const replane = useAppReplane();
+*   // replane.get("theme") returns { darkMode: boolean }
+* }
+* ```
+*/
+function createReplaneHook() {
+	return function useTypedReplane() {
+		return useReplane();
+	};
+}
+/**
+* Creates a typed version of useConfig hook.
+*
+* @example
+* ```tsx
+* interface AppConfigs {
+*   theme: { darkMode: boolean };
+*   features: { beta: boolean };
+* }
+*
+* const useAppConfig = createConfigHook<AppConfigs>();
+*
+* function MyComponent() {
+*   const theme = useAppConfig("theme");
+*   // theme is typed as { darkMode: boolean }
+* }
+* ```
+*/
+function createConfigHook() {
+	return function useTypedConfig(name, options) {
+		return useConfig(String(name), options);
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'Replane', {
+  enumerable: true,
+  get: function () {
+    return __replanejs_sdk.Replane;
+  }
+});
+Object.defineProperty(exports, 'ReplaneError', {
+  enumerable: true,
+  get: function () {
+    return __replanejs_sdk.ReplaneError;
+  }
+});
+Object.defineProperty(exports, 'ReplaneErrorCode', {
+  enumerable: true,
+  get: function () {
+    return __replanejs_sdk.ReplaneErrorCode;
+  }
+});
 exports.ReplaneProvider = ReplaneProvider;
 exports.clearSuspenseCache = clearSuspenseCache;
 exports.createConfigHook = createConfigHook;

package/dist/index.d.cts

@@ -1,23 +1,80 @@
 import * as react_jsx_runtime0 from "react/jsx-runtime";
-import { GetConfigOptions, GetReplaneSnapshotOptions, ReplaneClient, ReplaneClientOptions, ReplaneSnapshot, getReplaneSnapshot } from "@replanejs/sdk";
+import { ConnectOptions, GetConfigOptions, GetConfigOptions as GetConfigOptions$1, GetReplaneSnapshotOptions, Replane, Replane as Replane$1, ReplaneContext, ReplaneContext as ReplaneContext$1, ReplaneError, ReplaneErrorCode, ReplaneLogger, ReplaneLogger as ReplaneLogger$1, ReplaneOptions, ReplaneSnapshot, ReplaneSnapshot as ReplaneSnapshot$1, getReplaneSnapshot } from "@replanejs/sdk";
 import { ReactNode } from "react";
 
 //#region src/types.d.ts
 type UntypedReplaneConfig = Record<string, unknown>;
+/**
+ * Combined options for ReplaneProvider.
+ * Includes both constructor options (context, logger, defaults) and connection options.
+ */
+interface ReplaneProviderOptions<T extends object = UntypedReplaneConfig> {
+  /**
+   * Base URL of the Replane instance (no trailing slash).
+   * @example "https://app.replane.dev"
+   */
+  baseUrl: string;
+  /**
+   * Project SDK key for authorization.
+   * @example "rp_XXXXXXXXX"
+   */
+  sdkKey: string;
+  /**
+   * Default context for all config evaluations.
+   * Can be overridden per-request in `client.get()`.
+   */
+  context?: ReplaneContext$1;
+  /**
+   * Optional logger (defaults to console).
+   */
+  logger?: ReplaneLogger$1;
+  /**
+   * Default values to use before connection is established.
+   */
+  defaults?: { [K in keyof T]?: T[K] };
+  /**
+   * Optional timeout in ms for the initial connection.
+   * @default 5000
+   */
+  connectTimeoutMs?: number;
+  /**
+   * Delay between retries in ms.
+   * @default 200
+   */
+  retryDelayMs?: number;
+  /**
+   * Optional timeout in ms for individual requests.
+   * @default 2000
+   */
+  requestTimeoutMs?: number;
+  /**
+   * Timeout in ms for SSE connection inactivity.
+   * @default 30000
+   */
+  inactivityTimeoutMs?: number;
+  /**
+   * Custom fetch implementation (useful for tests / polyfills).
+   */
+  fetchFn?: typeof fetch;
+  /**
+   * Agent identifier sent in User-Agent header.
+   */
+  agent?: string;
+}
 /**
  * Props for ReplaneProvider when using a pre-created client.
  */
 interface ReplaneProviderWithClientProps<T extends object = UntypedReplaneConfig> {
-  /** Pre-created ReplaneClient instance */
-  client: ReplaneClient<T>;
+  /** Pre-created Replane client instance */
+  client: Replane$1<T>;
   children: ReactNode;
 }
 /**
  * Props for ReplaneProvider when letting it manage the client internally.
  */
 interface ReplaneProviderWithOptionsProps<T extends object = UntypedReplaneConfig> {
-  /** Options to create or restore the ReplaneClient */
-  options: ReplaneClientOptions<T>;
+  /** Options to create or restore the Replane client */
+  options: ReplaneProviderOptions<T>;
   children: ReactNode;
   /**
    * Optional snapshot from server-side rendering.
@@ -25,7 +82,7 @@ interface ReplaneProviderWithOptionsProps<T extends object = UntypedReplaneConfi
    * instead of fetching configs from the server.
    * The `options` will be used for live updates connection if provided.
    */
-  snapshot?: ReplaneSnapshot<T>;
+  snapshot?: ReplaneSnapshot$1<T>;
   /**
    * Optional loading component to show while the client is initializing.
    * If not provided and suspense is false/undefined, children will not render until ready.
@@ -44,17 +101,17 @@ type ReplaneProviderProps<T extends object = UntypedReplaneConfig> = ReplaneProv
 /**
  * Type guard to check if props contain a pre-created client.
  */
-
 //#endregion
 //#region src/provider.d.ts
 /**
- * Provider component that makes a ReplaneClient available to the component tree.
+ * Provider component that makes a Replane client available to the component tree.
  *
- * Can be used in three ways:
+ * Can be used in several ways:
  *
  * 1. With a pre-created client:
  * ```tsx
- * const client = await createReplaneClient({ ... });
+ * const client = new Replane({ defaults: { ... } });
+ * await client.connect({ baseUrl: '...', sdkKey: '...' });
  * <ReplaneProvider client={client}>
  *   <App />
  * </ReplaneProvider>
@@ -107,8 +164,8 @@ declare function ReplaneProvider<T extends object>(props: ReplaneProviderProps<T
 //# sourceMappingURL=provider.d.ts.map
 //#endregion
 //#region src/hooks.d.ts
-declare function useReplane<T extends object = UntypedReplaneConfig>(): ReplaneClient<T>;
-declare function useConfig<T>(name: string, options?: GetConfigOptions<T>): T;
+declare function useReplane<T extends object = UntypedReplaneConfig>(): Replane$1<T>;
+declare function useConfig<T>(name: string, options?: GetConfigOptions$1<T>): T;
 /**
  * Creates a typed version of useReplane hook.
  *
@@ -127,7 +184,7 @@ declare function useConfig<T>(name: string, options?: GetConfigOptions<T>): T;
  * }
  * ```
  */
-declare function createReplaneHook<TConfigs extends object>(): () => ReplaneClient<TConfigs>;
+declare function createReplaneHook<TConfigs extends object>(): () => Replane$1<TConfigs>;
 /**
  * Creates a typed version of useConfig hook.
  *
@@ -146,22 +203,15 @@ declare function createReplaneHook<TConfigs extends object>(): () => ReplaneClie
  * }
  * ```
  */
-declare function createConfigHook<TConfigs extends object>(): <K extends keyof TConfigs>(name: K, options?: GetConfigOptions<TConfigs[K]>) => TConfigs[K];
-/**
- * Hook for creating stateful resources with cleanup support.
- * Unlike useMemo, this guarantees cleanup when dependencies change or on unmount.
- *
- * @param factory - Function that creates the resource
- * @param cleanup - Function that cleans up the resource
- * @param deps - Dependencies array (resource is recreated when these change)
- */
+declare function createConfigHook<TConfigs extends object>(): <K extends keyof TConfigs>(name: K, options?: GetConfigOptions$1<TConfigs[K]>) => TConfigs[K];
+//# sourceMappingURL=hooks.d.ts.map
 //#endregion
 //#region src/useReplaneClient.d.ts
 /**
  * Clear the suspense cache for a specific options configuration.
  * Useful for testing or when you need to force re-initialization.
  */
-declare function clearSuspenseCache<T extends object>(options?: ReplaneClientOptions<T>): void;
+declare function clearSuspenseCache<T extends object>(options?: ReplaneProviderOptions<T>): void;
 //#endregion
-export { type GetReplaneSnapshotOptions, ReplaneProvider, type ReplaneProviderProps, type ReplaneProviderWithClientProps, type ReplaneProviderWithOptionsProps, clearSuspenseCache, createConfigHook, createReplaneHook, getReplaneSnapshot, useConfig, useReplane };
+export { type ConnectOptions, type GetConfigOptions, type GetReplaneSnapshotOptions, Replane, type ReplaneContext, ReplaneError, ReplaneErrorCode, type ReplaneLogger, type ReplaneOptions, ReplaneProvider, type ReplaneProviderOptions, type ReplaneProviderProps, type ReplaneProviderWithClientProps, type ReplaneProviderWithOptionsProps, type ReplaneSnapshot, clearSuspenseCache, createConfigHook, createReplaneHook, getReplaneSnapshot, useConfig, useReplane };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/provider.tsx","../src/hooks.ts","../src/useReplaneClient.ts"],"sourcesContent":[],"mappings":";;;;;KAOY,oBAAA,GAAuB;AASnC;;;AAEwB,UAFP,8BAEO,CAAA,UAAA,MAAA,GAF2C,oBAE3C,CAAA,CAAA;EAAC;EAAF,MACX,EADF,aACE,CADY,CACZ,CAAA;EAAS,QAAA,EAAT,SAAS;AAMrB;;;;AAEW,UAFM,+BAEN,CAAA,UAAA,MAAA,GAFyD,oBAEzD,CAAA,CAAA;EAAoB;EACV,OAOQ,EARlB,oBAQkB,CARG,CAQH,CAAA;EAAC,QAAjB,EAPD,SAOC;EAAe;AAMR;AAUpB;;;;EACoC,QAAhC,CAAA,EAjBS,eAiBT,CAjByB,CAiBzB,CAAA;EAA8B;;AACC;;;WAZxB;ECgHK;;;;;AAAgE;;;KDtGpE,wCAAwC,wBAChD,+BAA+B,KAC/B,gCAAgC;AE9CpC;;;;;;;;;;AFAA;AASA;;;;;;AAGqB;AAMrB;;;;;;;;;AAgBoB;AAUpB;;;;;;;AAEmC;;;;ACoGnC;;;;;AAAgF;;;;AClJhF;;;;;AAAoF;AAQpF;;;;;AAA4E;AAqC5E;;AACmD,iBDoGnC,eCpGmC,CAAA,UAAA,MAAA,CAAA,CAAA,KAAA,EDoGM,oBCpGN,CDoG2B,CCpG3B,CAAA,CAAA,EDoG6B,kBAAA,CAAA,GAAA,CAAA,OCpG7B;;;;iBA9CnC,8BAA8B,yBAAyB,cAAc;iBAQrE,qCAAqC,iBAAiB,KAAK;;AFR3E;AASA;;;;;;AAGqB;AAMrB;;;;;;;;;AAgBoB,iBEWJ,iBFXI,CAAA,iBAAA,MAAA,CAAA,CAAA,CAAA,EAAA,GAAA,GEYiB,aFZjB,CEY+B,QFZ/B,CAAA;AAUpB;;;;;;;AAEmC;;;;ACoGnC;;;;;AAAgF;;iBC7EhE,8DACiC,gBACvC,aACI,iBAAiB,SAAS,QACnC,SAAS;;AAzEd;;;;;AAAoF;AAQpF;;;;;;;AFsCoC,iBGgFpB,kBHhFoB,CAAA,UAAA,MAAA,CAAA,CAAA,OAAA,CAAA,EGgF2B,oBHhF3B,CGgFgD,CHhFhD,CAAA,CAAA,EAAA,IAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/provider.tsx","../src/hooks.ts","../src/useReplaneClient.ts"],"sourcesContent":[],"mappings":";;;;;KAGY,oBAAA,GAAuB;AAUnC;;;;AAmBW,UAnBM,sBAmBN,CAAA,UAAA,MAAA,GAnBgD,oBAmBhD,CAAA,CAAA;EAAa;;;;EA4BA,OAAA,EAAA,MAAA;EAUP;;;;EAEE,MAAT,EAAA,MAAA;EAAO;AACI;AAMrB;;EAAgD,OAAoB,CAAA,EAnDxD,gBAmDwD;EAAoB;;;EAGnE,MAOQ,CAAA,EAzDlB,eAyDkB;EAAC;;AAMV;EAUR,QAAA,CAAA,EAAA,QAAoB,MArEL,CAqEK,IArEA,CAqEA,CArEE,CAqEF,CAAA,EAAA;EAAwC;;;;EAErC,gBAAA,CAAA,EAAA,MAAA;;;;ACqEnC;EAA+B,YAAA,CAAA,EAAA,MAAA;EAAA;;;AAAiD;;;;ACzKhF;;EAA0B,mBAAoB,CAAA,EAAA,MAAA;EAAoB;;AAAY;EAQ9D,OAAA,CAAA,EAAA,OF6CG,KE7CM;EAAA;;;EAA4C,KAAM,CAAA,EAAA,MAAA;AAAC;AAqC5E;;;AACqC,UFiBpB,8BEjBoB,CAAA,UAAA,MAAA,GFiB8B,oBEjB9B,CAAA,CAAA;EAAO;EAuB5B,MAAA,EFJN,SEIM,CFJE,CEIF,CAAA;EAAgB,QAAA,EFHpB,SEGoB;;;;;AAGlB,UFAG,+BEAH,CAAA,UAAA,MAAA,GFAsD,oBEAtD,CAAA,CAAA;EAAgB;EACjB,OAAC,EFCH,sBEDG,CFCoB,CEDpB,CAAA;EAAC,QAAA,EFEH,SEFG;;;;ACyEf;;;EAAuF,QAAxB,CAAA,EHhElD,iBGgEkD,CHhElC,CGgEkC,CAAA;EAAsB;;;;;WH1D1E;;;;;;;;;KAUC,wCAAwC,wBAChD,+BAA+B,KAC/B,gCAAgC;;;;;;;;;;AAxGpC;AAUA;;;;;;;;;AA+CwB;AAUxB;;;;;;AAGqB;AAMrB;;;;;;;;;AAgBoB;AAUpB;;;;;;;AAEmC;;;;ACqEnC;;;;;AAAgF;;;;ACzKhF;;;;;AAA8E,iBDyK9D,eCzK8D,CAAA,UAAA,MAAA,CAAA,CAAA,KAAA,EDyKrB,oBCzKqB,CDyKA,CCzKA,CAAA,CAAA,EDyKE,kBAAA,CAAA,GAAA,CAAA,OCzKF;AAQ9E;;;iBARgB,8BAA8B,yBAAyB,UAAQ;iBAQ/D,qCAAqC,mBAAiB,KAAK;;AFZ3E;AAUA;;;;;;;;;AA+CwB;AAUxB;;;;;;AAGqB,iBErBL,iBFqBK,CAAA,iBAAA,MAAA,CAAA,CAAA,CAAA,EAAA,GAAA,GEpBgB,SFoBhB,CEpBwB,QFoBxB,CAAA;AAMrB;;;;;;;;;AAgBoB;AAUpB;;;;;;;AAEmC;iBE/BnB,8DACiC,gBACvC,aACI,mBAAiB,SAAS,QACnC,SAAS;;;;;;;;AFSe,iBGgEb,kBHhEa,CAAA,UAAA,MAAA,CAAA,CAAA,OAAA,CAAA,EGgEkC,sBHhElC,CGgEyD,CHhEzD,CAAA,CAAA,EAAA,IAAA"}

package/dist/index.d.ts

@@ -1,23 +1,80 @@
 import { ReactNode } from "react";
-import { GetConfigOptions, GetReplaneSnapshotOptions, ReplaneClient, ReplaneClientOptions, ReplaneSnapshot, getReplaneSnapshot } from "@replanejs/sdk";
+import { ConnectOptions, GetConfigOptions, GetConfigOptions as GetConfigOptions$1, GetReplaneSnapshotOptions, Replane, Replane as Replane$1, ReplaneContext, ReplaneContext as ReplaneContext$1, ReplaneError, ReplaneErrorCode, ReplaneLogger, ReplaneLogger as ReplaneLogger$1, ReplaneOptions, ReplaneSnapshot, ReplaneSnapshot as ReplaneSnapshot$1, getReplaneSnapshot } from "@replanejs/sdk";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
 
 //#region src/types.d.ts
 type UntypedReplaneConfig = Record<string, unknown>;
+/**
+ * Combined options for ReplaneProvider.
+ * Includes both constructor options (context, logger, defaults) and connection options.
+ */
+interface ReplaneProviderOptions<T extends object = UntypedReplaneConfig> {
+  /**
+   * Base URL of the Replane instance (no trailing slash).
+   * @example "https://app.replane.dev"
+   */
+  baseUrl: string;
+  /**
+   * Project SDK key for authorization.
+   * @example "rp_XXXXXXXXX"
+   */
+  sdkKey: string;
+  /**
+   * Default context for all config evaluations.
+   * Can be overridden per-request in `client.get()`.
+   */
+  context?: ReplaneContext$1;
+  /**
+   * Optional logger (defaults to console).
+   */
+  logger?: ReplaneLogger$1;
+  /**
+   * Default values to use before connection is established.
+   */
+  defaults?: { [K in keyof T]?: T[K] };
+  /**
+   * Optional timeout in ms for the initial connection.
+   * @default 5000
+   */
+  connectTimeoutMs?: number;
+  /**
+   * Delay between retries in ms.
+   * @default 200
+   */
+  retryDelayMs?: number;
+  /**
+   * Optional timeout in ms for individual requests.
+   * @default 2000
+   */
+  requestTimeoutMs?: number;
+  /**
+   * Timeout in ms for SSE connection inactivity.
+   * @default 30000
+   */
+  inactivityTimeoutMs?: number;
+  /**
+   * Custom fetch implementation (useful for tests / polyfills).
+   */
+  fetchFn?: typeof fetch;
+  /**
+   * Agent identifier sent in User-Agent header.
+   */
+  agent?: string;
+}
 /**
  * Props for ReplaneProvider when using a pre-created client.
  */
 interface ReplaneProviderWithClientProps<T extends object = UntypedReplaneConfig> {
-  /** Pre-created ReplaneClient instance */
-  client: ReplaneClient<T>;
+  /** Pre-created Replane client instance */
+  client: Replane$1<T>;
   children: ReactNode;
 }
 /**
  * Props for ReplaneProvider when letting it manage the client internally.
  */
 interface ReplaneProviderWithOptionsProps<T extends object = UntypedReplaneConfig> {
-  /** Options to create or restore the ReplaneClient */
-  options: ReplaneClientOptions<T>;
+  /** Options to create or restore the Replane client */
+  options: ReplaneProviderOptions<T>;
   children: ReactNode;
   /**
    * Optional snapshot from server-side rendering.
@@ -25,7 +82,7 @@ interface ReplaneProviderWithOptionsProps<T extends object = UntypedReplaneConfi
    * instead of fetching configs from the server.
    * The `options` will be used for live updates connection if provided.
    */
-  snapshot?: ReplaneSnapshot<T>;
+  snapshot?: ReplaneSnapshot$1<T>;
   /**
    * Optional loading component to show while the client is initializing.
    * If not provided and suspense is false/undefined, children will not render until ready.
@@ -44,17 +101,17 @@ type ReplaneProviderProps<T extends object = UntypedReplaneConfig> = ReplaneProv
 /**
  * Type guard to check if props contain a pre-created client.
  */
-
 //#endregion
 //#region src/provider.d.ts
 /**
- * Provider component that makes a ReplaneClient available to the component tree.
+ * Provider component that makes a Replane client available to the component tree.
  *
- * Can be used in three ways:
+ * Can be used in several ways:
  *
  * 1. With a pre-created client:
  * ```tsx
- * const client = await createReplaneClient({ ... });
+ * const client = new Replane({ defaults: { ... } });
+ * await client.connect({ baseUrl: '...', sdkKey: '...' });
  * <ReplaneProvider client={client}>
  *   <App />
  * </ReplaneProvider>
@@ -107,8 +164,8 @@ declare function ReplaneProvider<T extends object>(props: ReplaneProviderProps<T
 //# sourceMappingURL=provider.d.ts.map
 //#endregion
 //#region src/hooks.d.ts
-declare function useReplane<T extends object = UntypedReplaneConfig>(): ReplaneClient<T>;
-declare function useConfig<T>(name: string, options?: GetConfigOptions<T>): T;
+declare function useReplane<T extends object = UntypedReplaneConfig>(): Replane$1<T>;
+declare function useConfig<T>(name: string, options?: GetConfigOptions$1<T>): T;
 /**
  * Creates a typed version of useReplane hook.
  *
@@ -127,7 +184,7 @@ declare function useConfig<T>(name: string, options?: GetConfigOptions<T>): T;
  * }
  * ```
  */
-declare function createReplaneHook<TConfigs extends object>(): () => ReplaneClient<TConfigs>;
+declare function createReplaneHook<TConfigs extends object>(): () => Replane$1<TConfigs>;
 /**
  * Creates a typed version of useConfig hook.
  *
@@ -146,22 +203,15 @@ declare function createReplaneHook<TConfigs extends object>(): () => ReplaneClie
  * }
  * ```
  */
-declare function createConfigHook<TConfigs extends object>(): <K extends keyof TConfigs>(name: K, options?: GetConfigOptions<TConfigs[K]>) => TConfigs[K];
-/**
- * Hook for creating stateful resources with cleanup support.
- * Unlike useMemo, this guarantees cleanup when dependencies change or on unmount.
- *
- * @param factory - Function that creates the resource
- * @param cleanup - Function that cleans up the resource
- * @param deps - Dependencies array (resource is recreated when these change)
- */
+declare function createConfigHook<TConfigs extends object>(): <K extends keyof TConfigs>(name: K, options?: GetConfigOptions$1<TConfigs[K]>) => TConfigs[K];
+//# sourceMappingURL=hooks.d.ts.map
 //#endregion
 //#region src/useReplaneClient.d.ts
 /**
  * Clear the suspense cache for a specific options configuration.
  * Useful for testing or when you need to force re-initialization.
  */
-declare function clearSuspenseCache<T extends object>(options?: ReplaneClientOptions<T>): void;
+declare function clearSuspenseCache<T extends object>(options?: ReplaneProviderOptions<T>): void;
 //#endregion
-export { type GetReplaneSnapshotOptions, ReplaneProvider, type ReplaneProviderProps, type ReplaneProviderWithClientProps, type ReplaneProviderWithOptionsProps, clearSuspenseCache, createConfigHook, createReplaneHook, getReplaneSnapshot, useConfig, useReplane };
+export { type ConnectOptions, type GetConfigOptions, type GetReplaneSnapshotOptions, Replane, type ReplaneContext, ReplaneError, ReplaneErrorCode, type ReplaneLogger, type ReplaneOptions, ReplaneProvider, type ReplaneProviderOptions, type ReplaneProviderProps, type ReplaneProviderWithClientProps, type ReplaneProviderWithOptionsProps, type ReplaneSnapshot, clearSuspenseCache, createConfigHook, createReplaneHook, getReplaneSnapshot, useConfig, useReplane };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/provider.tsx","../src/hooks.ts","../src/useReplaneClient.ts"],"sourcesContent":[],"mappings":";;;;;KAOY,oBAAA,GAAuB;AASnC;;;AAEwB,UAFP,8BAEO,CAAA,UAAA,MAAA,GAF2C,oBAE3C,CAAA,CAAA;EAAC;EAAF,MACX,EADF,aACE,CADY,CACZ,CAAA;EAAS,QAAA,EAAT,SAAS;AAMrB;;;;AAEW,UAFM,+BAEN,CAAA,UAAA,MAAA,GAFyD,oBAEzD,CAAA,CAAA;EAAoB;EACV,OAOQ,EARlB,oBAQkB,CARG,CAQH,CAAA;EAAC,QAAjB,EAPD,SAOC;EAAe;AAMR;AAUpB;;;;EACoC,QAAhC,CAAA,EAjBS,eAiBT,CAjByB,CAiBzB,CAAA;EAA8B;;AACC;;;WAZxB;ECgHK;;;;;AAAgE;;;KDtGpE,wCAAwC,wBAChD,+BAA+B,KAC/B,gCAAgC;AE9CpC;;;;;;;;;;AFAA;AASA;;;;;;AAGqB;AAMrB;;;;;;;;;AAgBoB;AAUpB;;;;;;;AAEmC;;;;ACoGnC;;;;;AAAgF;;;;AClJhF;;;;;AAAoF;AAQpF;;;;;AAA4E;AAqC5E;;AACmD,iBDoGnC,eCpGmC,CAAA,UAAA,MAAA,CAAA,CAAA,KAAA,EDoGM,oBCpGN,CDoG2B,CCpG3B,CAAA,CAAA,EDoG6B,kBAAA,CAAA,GAAA,CAAA,OCpG7B;;;;iBA9CnC,8BAA8B,yBAAyB,cAAc;iBAQrE,qCAAqC,iBAAiB,KAAK;;AFR3E;AASA;;;;;;AAGqB;AAMrB;;;;;;;;;AAgBoB,iBEWJ,iBFXI,CAAA,iBAAA,MAAA,CAAA,CAAA,CAAA,EAAA,GAAA,GEYiB,aFZjB,CEY+B,QFZ/B,CAAA;AAUpB;;;;;;;AAEmC;;;;ACoGnC;;;;;AAAgF;;iBC7EhE,8DACiC,gBACvC,aACI,iBAAiB,SAAS,QACnC,SAAS;;AAzEd;;;;;AAAoF;AAQpF;;;;;;;AFsCoC,iBGgFpB,kBHhFoB,CAAA,UAAA,MAAA,CAAA,CAAA,OAAA,CAAA,EGgF2B,oBHhF3B,CGgFgD,CHhFhD,CAAA,CAAA,EAAA,IAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/provider.tsx","../src/hooks.ts","../src/useReplaneClient.ts"],"sourcesContent":[],"mappings":";;;;;KAGY,oBAAA,GAAuB;AAUnC;;;;AAmBW,UAnBM,sBAmBN,CAAA,UAAA,MAAA,GAnBgD,oBAmBhD,CAAA,CAAA;EAAa;;;;EA4BA,OAAA,EAAA,MAAA;EAUP;;;;EAEE,MAAT,EAAA,MAAA;EAAO;AACI;AAMrB;;EAAgD,OAAoB,CAAA,EAnDxD,gBAmDwD;EAAoB;;;EAGnE,MAOQ,CAAA,EAzDlB,eAyDkB;EAAC;;AAMV;EAUR,QAAA,CAAA,EAAA,QAAoB,MArEL,CAqEK,IArEA,CAqEA,CArEE,CAqEF,CAAA,EAAA;EAAwC;;;;EAErC,gBAAA,CAAA,EAAA,MAAA;;;;ACqEnC;EAA+B,YAAA,CAAA,EAAA,MAAA;EAAA;;;AAAiD;;;;ACzKhF;;EAA0B,mBAAoB,CAAA,EAAA,MAAA;EAAoB;;AAAY;EAQ9D,OAAA,CAAA,EAAA,OF6CG,KE7CM;EAAA;;;EAA4C,KAAM,CAAA,EAAA,MAAA;AAAC;AAqC5E;;;AACqC,UFiBpB,8BEjBoB,CAAA,UAAA,MAAA,GFiB8B,oBEjB9B,CAAA,CAAA;EAAO;EAuB5B,MAAA,EFJN,SEIM,CFJE,CEIF,CAAA;EAAgB,QAAA,EFHpB,SEGoB;;;;;AAGlB,UFAG,+BEAH,CAAA,UAAA,MAAA,GFAsD,oBEAtD,CAAA,CAAA;EAAgB;EACjB,OAAC,EFCH,sBEDG,CFCoB,CEDpB,CAAA;EAAC,QAAA,EFEH,SEFG;;;;ACyEf;;;EAAuF,QAAxB,CAAA,EHhElD,iBGgEkD,CHhElC,CGgEkC,CAAA;EAAsB;;;;;WH1D1E;;;;;;;;;KAUC,wCAAwC,wBAChD,+BAA+B,KAC/B,gCAAgC;;;;;;;;;;AAxGpC;AAUA;;;;;;;;;AA+CwB;AAUxB;;;;;;AAGqB;AAMrB;;;;;;;;;AAgBoB;AAUpB;;;;;;;AAEmC;;;;ACqEnC;;;;;AAAgF;;;;ACzKhF;;;;;AAA8E,iBDyK9D,eCzK8D,CAAA,UAAA,MAAA,CAAA,CAAA,KAAA,EDyKrB,oBCzKqB,CDyKA,CCzKA,CAAA,CAAA,EDyKE,kBAAA,CAAA,GAAA,CAAA,OCzKF;AAQ9E;;;iBARgB,8BAA8B,yBAAyB,UAAQ;iBAQ/D,qCAAqC,mBAAiB,KAAK;;AFZ3E;AAUA;;;;;;;;;AA+CwB;AAUxB;;;;;;AAGqB,iBErBL,iBFqBK,CAAA,iBAAA,MAAA,CAAA,CAAA,CAAA,EAAA,GAAA,GEpBgB,SFoBhB,CEpBwB,QFoBxB,CAAA;AAMrB;;;;;;;;;AAgBoB;AAUpB;;;;;;;AAEmC;iBE/BnB,8DACiC,gBACvC,aACI,mBAAiB,SAAS,QACnC,SAAS;;;;;;;;AFSe,iBGgEb,kBHhEa,CAAA,UAAA,MAAA,CAAA,CAAA,OAAA,CAAA,EGgEkC,sBHhElC,CGgEyD,CHhEzD,CAAA,CAAA,EAAA,IAAA"}

package/dist/index.js

@@ -2,15 +2,15 @@
 
 
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
-import { createReplaneClient, getReplaneSnapshot, restoreReplaneClient } from "@replanejs/sdk";
+import { Replane, Replane as Replane$1, ReplaneError, ReplaneErrorCode, getReplaneSnapshot } from "@replanejs/sdk";
 import { Fragment, jsx } from "react/jsx-runtime";
 
 //#region src/context.ts
-const ReplaneContext = createContext(null);
+const ReplaneContext$1 = createContext(null);
 
 //#endregion
 //#region src/version.ts
-const VERSION = "0.8.20";
+const VERSION = "0.9.0";
 const DEFAULT_AGENT = `replane-js-react/${VERSION}`;
 
 //#endregion
@@ -20,7 +20,28 @@ function getCacheKey(options) {
 	return `${options.baseUrl}:${options.sdkKey}`;
 }
 /**
-* Hook to manage ReplaneClient creation internally.
+* Creates a Replane client and connects it.
+*/
+async function createAndConnectClient(options) {
+	const client = new Replane$1({
+		logger: options.logger,
+		context: options.context,
+		defaults: options.defaults
+	});
+	await client.connect({
+		baseUrl: options.baseUrl,
+		sdkKey: options.sdkKey,
+		connectTimeoutMs: options.connectTimeoutMs,
+		retryDelayMs: options.retryDelayMs,
+		requestTimeoutMs: options.requestTimeoutMs,
+		inactivityTimeoutMs: options.inactivityTimeoutMs,
+		fetchFn: options.fetchFn,
+		agent: options.agent ?? DEFAULT_AGENT
+	});
+	return client;
+}
+/**
+* Hook to manage Replane client creation internally.
 * Handles loading state and cleanup.
 */
 function useReplaneClientInternal(options) {
@@ -35,12 +56,9 @@ function useReplaneClientInternal(options) {
 		let cancelled = false;
 		async function initClient() {
 			try {
-				const client = await createReplaneClient({
-					...optionsRef.current,
-					agent: optionsRef.current.agent ?? DEFAULT_AGENT
-				});
+				const client = await createAndConnectClient(optionsRef.current);
 				if (cancelled) {
-					client.close();
+					client.disconnect();
 					return;
 				}
 				clientRef.current = client;
@@ -63,7 +81,7 @@ function useReplaneClientInternal(options) {
 		return () => {
 			cancelled = true;
 			if (clientRef.current) {
-				clientRef.current.close();
+				clientRef.current.disconnect();
 				clientRef.current = null;
 			}
 		};
@@ -82,10 +100,7 @@ function useReplaneClientSuspense(options) {
 		if (cached.result) return cached.result;
 		throw cached.promise;
 	}
-	const promise = createReplaneClient({
-		...options,
-		agent: options.agent ?? DEFAULT_AGENT
-	}).then((client) => {
+	const promise = createAndConnectClient(options).then((client) => {
 		const entry = suspenseCache.get(cacheKey);
 		if (entry) entry.result = client;
 		return client;
@@ -106,101 +121,6 @@ function clearSuspenseCache(options) {
 	else suspenseCache.clear();
 }
 
-//#endregion
-//#region src/hooks.ts
-function useReplane() {
-	const context = useContext(ReplaneContext);
-	if (!context) throw new Error("useReplane must be used within a ReplaneProvider");
-	return context.client;
-}
-function useConfig(name, options) {
-	const client = useReplane();
-	const subscribe = useCallback((callback) => {
-		return client.subscribe(name, callback);
-	}, [client, name]);
-	const get = useCallback(() => {
-		return client.get(name, options);
-	}, [
-		client,
-		name,
-		options
-	]);
-	const value = useSyncExternalStore(subscribe, get, get);
-	return value;
-}
-/**
-* Creates a typed version of useReplane hook.
-*
-* @example
-* ```tsx
-* interface AppConfigs {
-*   theme: { darkMode: boolean };
-*   features: { beta: boolean };
-* }
-*
-* const useAppReplane = createReplaneHook<AppConfigs>();
-*
-* function MyComponent() {
-*   const replane = useAppReplane();
-*   // replane.get("theme") returns { darkMode: boolean }
-* }
-* ```
-*/
-function createReplaneHook() {
-	return function useTypedReplane() {
-		return useReplane();
-	};
-}
-/**
-* Creates a typed version of useConfig hook.
-*
-* @example
-* ```tsx
-* interface AppConfigs {
-*   theme: { darkMode: boolean };
-*   features: { beta: boolean };
-* }
-*
-* const useAppConfig = createConfigHook<AppConfigs>();
-*
-* function MyComponent() {
-*   const theme = useAppConfig("theme");
-*   // theme is typed as { darkMode: boolean }
-* }
-* ```
-*/
-function createConfigHook() {
-	return function useTypedConfig(name, options) {
-		return useConfig(String(name), options);
-	};
-}
-/**
-* Hook for creating stateful resources with cleanup support.
-* Unlike useMemo, this guarantees cleanup when dependencies change or on unmount.
-*
-* @param factory - Function that creates the resource
-* @param cleanup - Function that cleans up the resource
-* @param deps - Dependencies array (resource is recreated when these change)
-*/
-function useStateful(factory, cleanup, deps) {
-	const valueRef = useRef(null);
-	const initializedRef = useRef(false);
-	if (!initializedRef.current) {
-		valueRef.current = factory();
-		initializedRef.current = true;
-	}
-	useEffect(() => {
-		if (valueRef.current === null) valueRef.current = factory();
-		return () => {
-			if (valueRef.current !== null) {
-				cleanup(valueRef.current);
-				valueRef.current = null;
-			}
-		};
-	}, deps);
-	return valueRef.current;
-}
-
 //#endregion
 //#region src/types.ts
 /**
@@ -216,33 +136,53 @@ function hasClient(props) {
 * Internal provider component for pre-created client.
 */
 function ReplaneProviderWithClient({ client, children }) {
-	const value = useMemo(() => ({ client }), [client]);
-	return /* @__PURE__ */ jsx(ReplaneContext.Provider, {
+	const value = useMemo(() => ({ replane: client }), [client]);
+	return /* @__PURE__ */ jsx(ReplaneContext$1.Provider, {
 		value,
 		children
 	});
 }
 /**
 * Internal provider component for restoring client from snapshot.
-* Uses restoreReplaneClient which is synchronous.
+* Creates a Replane client synchronously and connects in background.
 */
 function ReplaneProviderWithSnapshot({ options, snapshot, children }) {
-	const client = useStateful(() => restoreReplaneClient({
+	const replaneRef = useRef(void 0);
+	if (!replaneRef.current) replaneRef.current = new Replane$1({
 		snapshot,
-		connection: {
+		logger: options.logger,
+		context: options.context,
+		defaults: options.defaults
+	});
+	useEffect(() => {
+		replaneRef.current.connect({
 			baseUrl: options.baseUrl,
 			sdkKey: options.sdkKey,
-			fetchFn: options.fetchFn,
-			requestTimeoutMs: options.requestTimeoutMs,
+			connectTimeoutMs: options.connectTimeoutMs,
 			retryDelayMs: options.retryDelayMs,
+			requestTimeoutMs: options.requestTimeoutMs,
 			inactivityTimeoutMs: options.inactivityTimeoutMs,
-			logger: options.logger,
+			fetchFn: options.fetchFn,
 			agent: options.agent ?? DEFAULT_AGENT
-		},
-		context: options.context
-	}), (c) => c.close(), [snapshot, options]);
-	const value = useMemo(() => ({ client }), [client]);
-	return /* @__PURE__ */ jsx(ReplaneContext.Provider, {
+		}).catch((err) => {
+			(options.logger ?? console)?.error("Failed to connect Replane client", err);
+		});
+		return () => {
+			replaneRef.current.disconnect();
+		};
+	}, [
+		options.agent,
+		options.baseUrl,
+		options.connectTimeoutMs,
+		options.fetchFn,
+		options.inactivityTimeoutMs,
+		options.logger,
+		options.requestTimeoutMs,
+		options.retryDelayMs,
+		options.sdkKey
+	]);
+	const value = useMemo(() => ({ replane: replaneRef.current }), []);
+	return /* @__PURE__ */ jsx(ReplaneContext$1.Provider, {
 		value,
 		children
 	});
@@ -255,8 +195,8 @@ function ReplaneProviderWithOptions({ options, children, loader }) {
 	const state = useReplaneClientInternal(options);
 	if (state.status === "loading") return /* @__PURE__ */ jsx(Fragment, { children: loader ?? null });
 	if (state.status === "error") throw state.error;
-	const value = { client: state.client };
-	return /* @__PURE__ */ jsx(ReplaneContext.Provider, {
+	const value = { replane: state.client };
+	return /* @__PURE__ */ jsx(ReplaneContext$1.Provider, {
 		value,
 		children
 	});
@@ -266,20 +206,21 @@ function ReplaneProviderWithOptions({ options, children, loader }) {
 */
 function ReplaneProviderWithSuspense({ options, children }) {
 	const client = useReplaneClientSuspense(options);
-	const value = useMemo(() => ({ client }), [client]);
-	return /* @__PURE__ */ jsx(ReplaneContext.Provider, {
+	const value = useMemo(() => ({ replane: client }), [client]);
+	return /* @__PURE__ */ jsx(ReplaneContext$1.Provider, {
 		value,
 		children
 	});
 }
 /**
-* Provider component that makes a ReplaneClient available to the component tree.
+* Provider component that makes a Replane client available to the component tree.
 *
-* Can be used in three ways:
+* Can be used in several ways:
 *
 * 1. With a pre-created client:
 * ```tsx
-* const client = await createReplaneClient({ ... });
+* const client = new Replane({ defaults: { ... } });
+* await client.connect({ baseUrl: '...', sdkKey: '...' });
 * <ReplaneProvider client={client}>
 *   <App />
 * </ReplaneProvider>
@@ -339,5 +280,74 @@ function ReplaneProvider(props) {
 }
 
 //#endregion
-export { ReplaneProvider, clearSuspenseCache, createConfigHook, createReplaneHook, getReplaneSnapshot, useConfig, useReplane };
+//#region src/hooks.ts
+function useReplane() {
+	const context = useContext(ReplaneContext$1);
+	if (!context) throw new Error("useReplane must be used within a ReplaneProvider");
+	return context.replane;
+}
+function useConfig(name, options) {
+	const client = useReplane();
+	const subscribe = useCallback((callback) => {
+		return client.subscribe(name, callback);
+	}, [client, name]);
+	const get = useCallback(() => {
+		return client.get(name, options);
+	}, [
+		client,
+		name,
+		options
+	]);
+	const value = useSyncExternalStore(subscribe, get, get);
+	return value;
+}
+/**
+* Creates a typed version of useReplane hook.
+*
+* @example
+* ```tsx
+* interface AppConfigs {
+*   theme: { darkMode: boolean };
+*   features: { beta: boolean };
+* }
+*
+* const useAppReplane = createReplaneHook<AppConfigs>();
+*
+* function MyComponent() {
+*   const replane = useAppReplane();
+*   // replane.get("theme") returns { darkMode: boolean }
+* }
+* ```
+*/
+function createReplaneHook() {
+	return function useTypedReplane() {
+		return useReplane();
+	};
+}
+/**
+* Creates a typed version of useConfig hook.
+*
+* @example
+* ```tsx
+* interface AppConfigs {
+*   theme: { darkMode: boolean };
+*   features: { beta: boolean };
+* }
+*
+* const useAppConfig = createConfigHook<AppConfigs>();
+*
+* function MyComponent() {
+*   const theme = useAppConfig("theme");
+*   // theme is typed as { darkMode: boolean }
+* }
+* ```
+*/
+function createConfigHook() {
+	return function useTypedConfig(name, options) {
+		return useConfig(String(name), options);
+	};
+}
+
+//#endregion
+export { Replane, ReplaneError, ReplaneErrorCode, ReplaneProvider, clearSuspenseCache, createConfigHook, createReplaneHook, getReplaneSnapshot, useConfig, useReplane };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["options: ReplaneClientOptions<T>","err: unknown","options?: ReplaneClientOptions<T>","name: string","options?: GetConfigOptions<T>","callback: () => void","name: K","options?: GetConfigOptions<TConfigs[K]>","factory: () => T","cleanup: (value: T) => void","deps: React.DependencyList","props: ReplaneProviderProps<T>","value: ReplaneContextValue<T>","props: ReplaneProviderProps<T>"],"sources":["../src/context.ts","../src/version.ts","../src/useReplaneClient.ts","../src/hooks.ts","../src/types.ts","../src/provider.tsx"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport type { ReplaneContextValue } from \"./types\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const ReplaneContext = createContext<ReplaneContextValue<any> | null>(null);\n","// Auto-generated - do not edit manually\nexport const VERSION = \"0.8.20\";\nexport const DEFAULT_AGENT = `replane-js-react/${VERSION}`;\n","\"use client\";\n\nimport { useEffect, useRef, useState } from \"react\";\nimport { createReplaneClient } from \"@replanejs/sdk\";\nimport type { ReplaneClient, ReplaneClientOptions } from \"@replanejs/sdk\";\nimport { DEFAULT_AGENT } from \"./version\";\n\ntype ClientState<T extends object> =\n  | { status: \"loading\"; client: null; error: null }\n  | { status: \"ready\"; client: ReplaneClient<T>; error: null }\n  | { status: \"error\"; client: null; error: Error };\n\n// Cache for suspense promise tracking\nconst suspenseCache = new Map<\n  string,\n  {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    promise: Promise<ReplaneClient<any>>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    result?: ReplaneClient<any>;\n    error?: Error;\n  }\n>();\n\nfunction getCacheKey<T extends object>(options: ReplaneClientOptions<T>): string {\n  return `${options.baseUrl}:${options.sdkKey}`;\n}\n\ntype ErrorConstructor = new (message: string, options?: { cause?: unknown }) => Error;\n\n/**\n * Hook to manage ReplaneClient creation internally.\n * Handles loading state and cleanup.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useReplaneClientInternal<T extends object = any>(\n  options: ReplaneClientOptions<T>\n): ClientState<T> {\n  const [state, setState] = useState<ClientState<T>>({\n    status: \"loading\",\n    client: null,\n    error: null,\n  });\n  const clientRef = useRef<ReplaneClient<T> | null>(null);\n  const optionsRef = useRef(options);\n\n  useEffect(() => {\n    let cancelled = false;\n\n    async function initClient() {\n      try {\n        const client = await createReplaneClient<T>({\n          ...optionsRef.current,\n          agent: optionsRef.current.agent ?? DEFAULT_AGENT,\n        });\n        if (cancelled) {\n          client.close();\n          return;\n        }\n        clientRef.current = client;\n        setState({ status: \"ready\", client, error: null });\n      } catch (err) {\n        if (cancelled) return;\n        const error =\n          err instanceof Error ? err : new (Error as ErrorConstructor)(String(err), { cause: err });\n        setState({ status: \"error\", client: null, error });\n      }\n    }\n\n    initClient();\n\n    return () => {\n      cancelled = true;\n      if (clientRef.current) {\n        clientRef.current.close();\n        clientRef.current = null;\n      }\n    };\n  }, []);\n\n  return state;\n}\n\n/**\n * Hook for Suspense-based client creation.\n * Throws a promise while loading, throws error on failure.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useReplaneClientSuspense<T extends object = any>(\n  options: ReplaneClientOptions<T>\n): ReplaneClient<T> {\n  const cacheKey = getCacheKey(options);\n  const cached = suspenseCache.get(cacheKey);\n\n  if (cached) {\n    if (cached.error) {\n      throw cached.error;\n    }\n    if (cached.result) {\n      return cached.result as ReplaneClient<T>;\n    }\n    // Still loading, throw the promise\n    throw cached.promise;\n  }\n\n  // First time - create the promise\n  const promise = createReplaneClient<T>({\n    ...options,\n    agent: options.agent ?? DEFAULT_AGENT,\n  })\n    .then((client) => {\n      const entry = suspenseCache.get(cacheKey);\n      if (entry) {\n        entry.result = client;\n      }\n      return client;\n    })\n    .catch((err: unknown) => {\n      const entry = suspenseCache.get(cacheKey);\n      if (entry) {\n        entry.error = err instanceof Error ? err : new Error(String(err));\n      }\n      throw err;\n    });\n\n  suspenseCache.set(cacheKey, { promise });\n  throw promise;\n}\n\n/**\n * Clear the suspense cache for a specific options configuration.\n * Useful for testing or when you need to force re-initialization.\n */\nexport function clearSuspenseCache<T extends object>(options?: ReplaneClientOptions<T>): void {\n  if (options) {\n    suspenseCache.delete(getCacheKey(options));\n  } else {\n    suspenseCache.clear();\n  }\n}\n","\"use client\";\n\nimport { useCallback, useContext, useEffect, useRef, useSyncExternalStore } from \"react\";\nimport { ReplaneContext } from \"./context\";\nimport type { UntypedReplaneConfig } from \"./types\";\nimport type { ReplaneClient, GetConfigOptions } from \"@replanejs/sdk\";\n\nexport function useReplane<T extends object = UntypedReplaneConfig>(): ReplaneClient<T> {\n  const context = useContext(ReplaneContext);\n  if (!context) {\n    throw new Error(\"useReplane must be used within a ReplaneProvider\");\n  }\n  return context.client as ReplaneClient<T>;\n}\n\nexport function useConfig<T>(name: string, options?: GetConfigOptions<T>): T {\n  const client = useReplane();\n\n  const subscribe = useCallback(\n    (callback: () => void) => {\n      return client.subscribe(name, callback);\n    },\n    [client, name]\n  );\n\n  const get = useCallback(() => {\n    return client.get(name, options) as T;\n  }, [client, name, options]);\n\n  const value = useSyncExternalStore(subscribe, get, get);\n\n  return value;\n}\n\n/**\n * Creates a typed version of useReplane hook.\n *\n * @example\n * ```tsx\n * interface AppConfigs {\n *   theme: { darkMode: boolean };\n *   features: { beta: boolean };\n * }\n *\n * const useAppReplane = createReplaneHook<AppConfigs>();\n *\n * function MyComponent() {\n *   const replane = useAppReplane();\n *   // replane.get(\"theme\") returns { darkMode: boolean }\n * }\n * ```\n */\nexport function createReplaneHook<TConfigs extends object>() {\n  return function useTypedReplane(): ReplaneClient<TConfigs> {\n    return useReplane<TConfigs>();\n  };\n}\n\n/**\n * Creates a typed version of useConfig hook.\n *\n * @example\n * ```tsx\n * interface AppConfigs {\n *   theme: { darkMode: boolean };\n *   features: { beta: boolean };\n * }\n *\n * const useAppConfig = createConfigHook<AppConfigs>();\n *\n * function MyComponent() {\n *   const theme = useAppConfig(\"theme\");\n *   // theme is typed as { darkMode: boolean }\n * }\n * ```\n */\nexport function createConfigHook<TConfigs extends object>() {\n  return function useTypedConfig<K extends keyof TConfigs>(\n    name: K,\n    options?: GetConfigOptions<TConfigs[K]>\n  ): TConfigs[K] {\n    return useConfig<TConfigs[K]>(String(name), options);\n  };\n}\n\n/**\n * Hook for creating stateful resources with cleanup support.\n * Unlike useMemo, this guarantees cleanup when dependencies change or on unmount.\n *\n * @param factory - Function that creates the resource\n * @param cleanup - Function that cleans up the resource\n * @param deps - Dependencies array (resource is recreated when these change)\n */\nexport function useStateful<T>(\n  factory: () => T,\n  cleanup: (value: T) => void,\n  deps: React.DependencyList\n): T {\n  const valueRef = useRef<T | null>(null);\n  const initializedRef = useRef(false);\n\n  // Create initial value synchronously on first render\n  if (!initializedRef.current) {\n    valueRef.current = factory();\n    initializedRef.current = true;\n  }\n\n  useEffect(() => {\n    // On mount or deps change, we may need to recreate\n    // If this is not the initial mount, recreate the value\n    if (valueRef.current === null) {\n      valueRef.current = factory();\n    }\n\n    return () => {\n      if (valueRef.current !== null) {\n        cleanup(valueRef.current);\n        valueRef.current = null;\n      }\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, deps);\n\n  return valueRef.current as T;\n}\n","import type {\n  ReplaneClient,\n  ReplaneClientOptions,\n  ReplaneSnapshot,\n} from \"@replanejs/sdk\";\nimport type { ReactNode } from \"react\";\n\nexport type UntypedReplaneConfig = Record<string, unknown>;\n\nexport interface ReplaneContextValue<T extends object = UntypedReplaneConfig> {\n  client: ReplaneClient<T>;\n}\n\n/**\n * Props for ReplaneProvider when using a pre-created client.\n */\nexport interface ReplaneProviderWithClientProps<T extends object = UntypedReplaneConfig> {\n  /** Pre-created ReplaneClient instance */\n  client: ReplaneClient<T>;\n  children: ReactNode;\n}\n\n/**\n * Props for ReplaneProvider when letting it manage the client internally.\n */\nexport interface ReplaneProviderWithOptionsProps<T extends object = UntypedReplaneConfig> {\n  /** Options to create or restore the ReplaneClient */\n  options: ReplaneClientOptions<T>;\n  children: ReactNode;\n  /**\n   * Optional snapshot from server-side rendering.\n   * When provided, the client will be restored from the snapshot synchronously\n   * instead of fetching configs from the server.\n   * The `options` will be used for live updates connection if provided.\n   */\n  snapshot?: ReplaneSnapshot<T>;\n  /**\n   * Optional loading component to show while the client is initializing.\n   * If not provided and suspense is false/undefined, children will not render until ready.\n   * Ignored when snapshot is provided (restoration is synchronous).\n   */\n  loader?: ReactNode;\n  /**\n   * If true, uses React Suspense for loading state.\n   * The provider will throw a promise that Suspense can catch.\n   * Ignored when snapshot is provided (restoration is synchronous).\n   * @default false\n   */\n  suspense?: boolean;\n}\n\nexport type ReplaneProviderProps<T extends object = UntypedReplaneConfig> =\n  | ReplaneProviderWithClientProps<T>\n  | ReplaneProviderWithOptionsProps<T>;\n\n/**\n * Type guard to check if props contain a pre-created client.\n */\nexport function hasClient<T extends object>(\n  props: ReplaneProviderProps<T>\n): props is ReplaneProviderWithClientProps<T> {\n  return \"client\" in props && props.client !== undefined;\n}\n\n/**\n * Type guard to check if props contain options (with or without snapshot).\n */\nexport function hasOptions<T extends object>(\n  props: ReplaneProviderProps<T>\n): props is ReplaneProviderWithOptionsProps<T> {\n  return \"options\" in props && props.options !== undefined;\n}\n","\"use client\";\n\nimport { useMemo } from \"react\";\nimport { restoreReplaneClient } from \"@replanejs/sdk\";\nimport { ReplaneContext } from \"./context\";\nimport { useReplaneClientInternal, useReplaneClientSuspense } from \"./useReplaneClient\";\nimport { useStateful } from \"./hooks\";\nimport type {\n  ReplaneProviderProps,\n  ReplaneProviderWithClientProps,\n  ReplaneProviderWithOptionsProps,\n  ReplaneContextValue,\n} from \"./types\";\nimport { hasClient } from \"./types\";\nimport { DEFAULT_AGENT } from \"./version\";\n\n/**\n * Internal provider component for pre-created client.\n */\nfunction ReplaneProviderWithClient<T extends object>({\n  client,\n  children,\n}: ReplaneProviderWithClientProps<T>) {\n  const value = useMemo<ReplaneContextValue<T>>(() => ({ client }), [client]);\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Internal provider component for restoring client from snapshot.\n * Uses restoreReplaneClient which is synchronous.\n */\nfunction ReplaneProviderWithSnapshot<T extends object>({\n  options,\n  snapshot,\n  children,\n}: ReplaneProviderWithOptionsProps<T> & {\n  snapshot: NonNullable<ReplaneProviderWithOptionsProps<T>[\"snapshot\"]>;\n}) {\n  const client = useStateful(\n    () =>\n      restoreReplaneClient<T>({\n        snapshot,\n        connection: {\n          baseUrl: options.baseUrl,\n          sdkKey: options.sdkKey,\n          fetchFn: options.fetchFn,\n          requestTimeoutMs: options.requestTimeoutMs,\n          retryDelayMs: options.retryDelayMs,\n          inactivityTimeoutMs: options.inactivityTimeoutMs,\n          logger: options.logger,\n          agent: options.agent ?? DEFAULT_AGENT,\n        },\n        context: options.context,\n      }),\n    (c) => c.close(),\n    [snapshot, options]\n  );\n  const value = useMemo<ReplaneContextValue<T>>(() => ({ client }), [client]);\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Internal provider component for options-based client creation (non-suspense).\n * Throws errors during rendering so they can be caught by Error Boundaries.\n */\nfunction ReplaneProviderWithOptions<T extends object>({\n  options,\n  children,\n  loader,\n}: ReplaneProviderWithOptionsProps<T>) {\n  const state = useReplaneClientInternal<T>(options);\n\n  if (state.status === \"loading\") {\n    return <>{loader ?? null}</>;\n  }\n\n  if (state.status === \"error\") {\n    // Throw error during render so it can be caught by Error Boundary\n    throw state.error;\n  }\n\n  const value: ReplaneContextValue<T> = { client: state.client };\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Internal provider component for options-based client creation with Suspense.\n */\nfunction ReplaneProviderWithSuspense<T extends object>({\n  options,\n  children,\n}: ReplaneProviderWithOptionsProps<T>) {\n  const client = useReplaneClientSuspense<T>(options);\n  const value = useMemo<ReplaneContextValue<T>>(() => ({ client }), [client]);\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Provider component that makes a ReplaneClient available to the component tree.\n *\n * Can be used in three ways:\n *\n * 1. With a pre-created client:\n * ```tsx\n * const client = await createReplaneClient({ ... });\n * <ReplaneProvider client={client}>\n *   <App />\n * </ReplaneProvider>\n * ```\n *\n * 2. With options (client managed internally):\n * ```tsx\n * <ErrorBoundary fallback={<ErrorMessage />}>\n *   <ReplaneProvider\n *     options={{ baseUrl: '...', sdkKey: '...' }}\n *     loader={<LoadingSpinner />}\n *   >\n *     <App />\n *   </ReplaneProvider>\n * </ErrorBoundary>\n * ```\n *\n * 3. With Suspense:\n * ```tsx\n * <ErrorBoundary fallback={<ErrorMessage />}>\n *   <Suspense fallback={<LoadingSpinner />}>\n *     <ReplaneProvider\n *       options={{ baseUrl: '...', sdkKey: '...' }}\n *       suspense\n *     >\n *       <App />\n *     </ReplaneProvider>\n *   </Suspense>\n * </ErrorBoundary>\n * ```\n *\n * 4. With a snapshot (for SSR/hydration):\n * ```tsx\n * // On the server, get a snapshot from the client\n * const snapshot = serverClient.getSnapshot();\n *\n * // On the client, restore from the snapshot with live updates\n * <ReplaneProvider\n *   options={{ baseUrl: '...', sdkKey: '...' }}\n *   snapshot={snapshot}\n * >\n *   <App />\n * </ReplaneProvider>\n * ```\n *\n * Errors during client initialization are thrown during rendering,\n * allowing them to be caught by React Error Boundaries.\n */\nexport function ReplaneProvider<T extends object>(props: ReplaneProviderProps<T>) {\n  if (hasClient(props)) {\n    return <ReplaneProviderWithClient {...props} />;\n  }\n\n  // Has options - check if snapshot is provided\n  if (props.snapshot) {\n    return <ReplaneProviderWithSnapshot {...props} snapshot={props.snapshot} />;\n  }\n\n  if (props.suspense) {\n    return <ReplaneProviderWithSuspense {...props} />;\n  }\n\n  return <ReplaneProviderWithOptions {...props} />;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["ReplaneContext","options: ReplaneProviderOptions<T>","Replane","err: unknown","options?: ReplaneProviderOptions<T>","props: ReplaneProviderProps<T>","ReplaneContext","Replane","value: ReplaneContextValue<T>","props: ReplaneProviderProps<T>","ReplaneContext","name: string","options?: GetConfigOptions<T>","callback: () => void","name: K","options?: GetConfigOptions<TConfigs[K]>"],"sources":["../src/context.ts","../src/version.ts","../src/useReplaneClient.ts","../src/types.ts","../src/provider.tsx","../src/hooks.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport type { ReplaneContextValue } from \"./types\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const ReplaneContext = createContext<ReplaneContextValue<any> | null>(null);\n","// Auto-generated - do not edit manually\nexport const VERSION = \"0.9.0\";\nexport const DEFAULT_AGENT = `replane-js-react/${VERSION}`;\n","\"use client\";\n\nimport { useEffect, useRef, useState } from \"react\";\nimport { Replane } from \"@replanejs/sdk\";\nimport { DEFAULT_AGENT } from \"./version\";\nimport type { ReplaneProviderOptions } from \"./types\";\n\ntype ClientState<T extends object> =\n  | { status: \"loading\"; client: null; error: null }\n  | { status: \"ready\"; client: Replane<T>; error: null }\n  | { status: \"error\"; client: null; error: Error };\n\n// Cache for suspense promise tracking\nconst suspenseCache = new Map<\n  string,\n  {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    promise: Promise<Replane<any>>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    result?: Replane<any>;\n    error?: Error;\n  }\n>();\n\nfunction getCacheKey<T extends object>(options: ReplaneProviderOptions<T>): string {\n  return `${options.baseUrl}:${options.sdkKey}`;\n}\n\n/**\n * Creates a Replane client and connects it.\n */\nasync function createAndConnectClient<T extends object>(\n  options: ReplaneProviderOptions<T>\n): Promise<Replane<T>> {\n  const client = new Replane<T>({\n    logger: options.logger,\n    context: options.context,\n    defaults: options.defaults,\n  });\n\n  await client.connect({\n    baseUrl: options.baseUrl,\n    sdkKey: options.sdkKey,\n    connectTimeoutMs: options.connectTimeoutMs,\n    retryDelayMs: options.retryDelayMs,\n    requestTimeoutMs: options.requestTimeoutMs,\n    inactivityTimeoutMs: options.inactivityTimeoutMs,\n    fetchFn: options.fetchFn,\n    agent: options.agent ?? DEFAULT_AGENT,\n  });\n\n  return client;\n}\n\ntype ErrorConstructor = new (message: string, options?: { cause?: unknown }) => Error;\n\n/**\n * Hook to manage Replane client creation internally.\n * Handles loading state and cleanup.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useReplaneClientInternal<T extends object = any>(\n  options: ReplaneProviderOptions<T>\n): ClientState<T> {\n  const [state, setState] = useState<ClientState<T>>({\n    status: \"loading\",\n    client: null,\n    error: null,\n  });\n  const clientRef = useRef<Replane<T> | null>(null);\n  const optionsRef = useRef(options);\n\n  useEffect(() => {\n    let cancelled = false;\n\n    async function initClient() {\n      try {\n        const client = await createAndConnectClient<T>(optionsRef.current);\n        if (cancelled) {\n          client.disconnect();\n          return;\n        }\n        clientRef.current = client;\n        setState({ status: \"ready\", client, error: null });\n      } catch (err) {\n        if (cancelled) return;\n        const error =\n          err instanceof Error ? err : new (Error as ErrorConstructor)(String(err), { cause: err });\n        setState({ status: \"error\", client: null, error });\n      }\n    }\n\n    initClient();\n\n    return () => {\n      cancelled = true;\n      if (clientRef.current) {\n        clientRef.current.disconnect();\n        clientRef.current = null;\n      }\n    };\n  }, []);\n\n  return state;\n}\n\n/**\n * Hook for Suspense-based client creation.\n * Throws a promise while loading, throws error on failure.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useReplaneClientSuspense<T extends object = any>(\n  options: ReplaneProviderOptions<T>\n): Replane<T> {\n  const cacheKey = getCacheKey(options);\n  const cached = suspenseCache.get(cacheKey);\n\n  if (cached) {\n    if (cached.error) {\n      throw cached.error;\n    }\n    if (cached.result) {\n      return cached.result as Replane<T>;\n    }\n    // Still loading, throw the promise\n    throw cached.promise;\n  }\n\n  // First time - create the promise\n  const promise = createAndConnectClient<T>(options)\n    .then((client) => {\n      const entry = suspenseCache.get(cacheKey);\n      if (entry) {\n        entry.result = client;\n      }\n      return client;\n    })\n    .catch((err: unknown) => {\n      const entry = suspenseCache.get(cacheKey);\n      if (entry) {\n        entry.error = err instanceof Error ? err : new Error(String(err));\n      }\n      throw err;\n    });\n\n  suspenseCache.set(cacheKey, { promise });\n  throw promise;\n}\n\n/**\n * Clear the suspense cache for a specific options configuration.\n * Useful for testing or when you need to force re-initialization.\n */\nexport function clearSuspenseCache<T extends object>(options?: ReplaneProviderOptions<T>): void {\n  if (options) {\n    suspenseCache.delete(getCacheKey(options));\n  } else {\n    suspenseCache.clear();\n  }\n}\n","import type { Replane, ReplaneSnapshot, ReplaneContext, ReplaneLogger } from \"@replanejs/sdk\";\nimport type { ReactNode } from \"react\";\n\nexport type UntypedReplaneConfig = Record<string, unknown>;\n\nexport interface ReplaneContextValue<T extends object = UntypedReplaneConfig> {\n  replane: Replane<T>;\n}\n\n/**\n * Combined options for ReplaneProvider.\n * Includes both constructor options (context, logger, defaults) and connection options.\n */\nexport interface ReplaneProviderOptions<T extends object = UntypedReplaneConfig> {\n  /**\n   * Base URL of the Replane instance (no trailing slash).\n   * @example \"https://app.replane.dev\"\n   */\n  baseUrl: string;\n  /**\n   * Project SDK key for authorization.\n   * @example \"rp_XXXXXXXXX\"\n   */\n  sdkKey: string;\n  /**\n   * Default context for all config evaluations.\n   * Can be overridden per-request in `client.get()`.\n   */\n  context?: ReplaneContext;\n  /**\n   * Optional logger (defaults to console).\n   */\n  logger?: ReplaneLogger;\n  /**\n   * Default values to use before connection is established.\n   */\n  defaults?: { [K in keyof T]?: T[K] };\n  /**\n   * Optional timeout in ms for the initial connection.\n   * @default 5000\n   */\n  connectTimeoutMs?: number;\n  /**\n   * Delay between retries in ms.\n   * @default 200\n   */\n  retryDelayMs?: number;\n  /**\n   * Optional timeout in ms for individual requests.\n   * @default 2000\n   */\n  requestTimeoutMs?: number;\n  /**\n   * Timeout in ms for SSE connection inactivity.\n   * @default 30000\n   */\n  inactivityTimeoutMs?: number;\n  /**\n   * Custom fetch implementation (useful for tests / polyfills).\n   */\n  fetchFn?: typeof fetch;\n  /**\n   * Agent identifier sent in User-Agent header.\n   */\n  agent?: string;\n}\n\n/**\n * Props for ReplaneProvider when using a pre-created client.\n */\nexport interface ReplaneProviderWithClientProps<T extends object = UntypedReplaneConfig> {\n  /** Pre-created Replane client instance */\n  client: Replane<T>;\n  children: ReactNode;\n}\n\n/**\n * Props for ReplaneProvider when letting it manage the client internally.\n */\nexport interface ReplaneProviderWithOptionsProps<T extends object = UntypedReplaneConfig> {\n  /** Options to create or restore the Replane client */\n  options: ReplaneProviderOptions<T>;\n  children: ReactNode;\n  /**\n   * Optional snapshot from server-side rendering.\n   * When provided, the client will be restored from the snapshot synchronously\n   * instead of fetching configs from the server.\n   * The `options` will be used for live updates connection if provided.\n   */\n  snapshot?: ReplaneSnapshot<T>;\n  /**\n   * Optional loading component to show while the client is initializing.\n   * If not provided and suspense is false/undefined, children will not render until ready.\n   * Ignored when snapshot is provided (restoration is synchronous).\n   */\n  loader?: ReactNode;\n  /**\n   * If true, uses React Suspense for loading state.\n   * The provider will throw a promise that Suspense can catch.\n   * Ignored when snapshot is provided (restoration is synchronous).\n   * @default false\n   */\n  suspense?: boolean;\n}\n\nexport type ReplaneProviderProps<T extends object = UntypedReplaneConfig> =\n  | ReplaneProviderWithClientProps<T>\n  | ReplaneProviderWithOptionsProps<T>;\n\n/**\n * Type guard to check if props contain a pre-created client.\n */\nexport function hasClient<T extends object>(\n  props: ReplaneProviderProps<T>\n): props is ReplaneProviderWithClientProps<T> {\n  return \"client\" in props && props.client !== undefined;\n}\n\n/**\n * Type guard to check if props contain options (with or without snapshot).\n */\nexport function hasOptions<T extends object>(\n  props: ReplaneProviderProps<T>\n): props is ReplaneProviderWithOptionsProps<T> {\n  return \"options\" in props && props.options !== undefined;\n}\n","\"use client\";\n\nimport { useEffect, useMemo, useRef } from \"react\";\nimport { Replane } from \"@replanejs/sdk\";\nimport { ReplaneContext } from \"./context\";\nimport { useReplaneClientInternal, useReplaneClientSuspense } from \"./useReplaneClient\";\nimport type {\n  ReplaneProviderProps,\n  ReplaneProviderWithClientProps,\n  ReplaneProviderWithOptionsProps,\n  ReplaneContextValue,\n} from \"./types\";\nimport { hasClient } from \"./types\";\nimport { DEFAULT_AGENT } from \"./version\";\n\n/**\n * Internal provider component for pre-created client.\n */\nfunction ReplaneProviderWithClient<T extends object>({\n  client,\n  children,\n}: ReplaneProviderWithClientProps<T>) {\n  const value = useMemo<ReplaneContextValue<T>>(() => ({ replane: client }), [client]);\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Internal provider component for restoring client from snapshot.\n * Creates a Replane client synchronously and connects in background.\n */\nfunction ReplaneProviderWithSnapshot<T extends object>({\n  options,\n  snapshot,\n  children,\n}: ReplaneProviderWithOptionsProps<T> & {\n  snapshot: NonNullable<ReplaneProviderWithOptionsProps<T>[\"snapshot\"]>;\n}) {\n  const replaneRef = useRef<Replane<T>>(undefined as unknown as Replane<T>);\n\n  if (!replaneRef.current) {\n    replaneRef.current = new Replane<T>({\n      snapshot,\n      logger: options.logger,\n      context: options.context,\n      defaults: options.defaults,\n    });\n  }\n\n  useEffect(() => {\n    replaneRef.current\n      .connect({\n        baseUrl: options.baseUrl,\n        sdkKey: options.sdkKey,\n        connectTimeoutMs: options.connectTimeoutMs,\n        retryDelayMs: options.retryDelayMs,\n        requestTimeoutMs: options.requestTimeoutMs,\n        inactivityTimeoutMs: options.inactivityTimeoutMs,\n        fetchFn: options.fetchFn,\n        agent: options.agent ?? DEFAULT_AGENT,\n      })\n      .catch((err) => {\n        (options.logger ?? console)?.error(\"Failed to connect Replane client\", err);\n      });\n\n    return () => {\n      replaneRef.current.disconnect();\n    };\n  }, [\n    options.agent,\n    options.baseUrl,\n    options.connectTimeoutMs,\n    options.fetchFn,\n    options.inactivityTimeoutMs,\n    options.logger,\n    options.requestTimeoutMs,\n    options.retryDelayMs,\n    options.sdkKey,\n  ]);\n\n  const value = useMemo<ReplaneContextValue<T>>(() => ({ replane: replaneRef.current }), []);\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Internal provider component for options-based client creation (non-suspense).\n * Throws errors during rendering so they can be caught by Error Boundaries.\n */\nfunction ReplaneProviderWithOptions<T extends object>({\n  options,\n  children,\n  loader,\n}: ReplaneProviderWithOptionsProps<T>) {\n  const state = useReplaneClientInternal<T>(options);\n\n  if (state.status === \"loading\") {\n    return <>{loader ?? null}</>;\n  }\n\n  if (state.status === \"error\") {\n    // Throw error during render so it can be caught by Error Boundary\n    throw state.error;\n  }\n\n  const value: ReplaneContextValue<T> = { replane: state.client };\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Internal provider component for options-based client creation with Suspense.\n */\nfunction ReplaneProviderWithSuspense<T extends object>({\n  options,\n  children,\n}: ReplaneProviderWithOptionsProps<T>) {\n  const client = useReplaneClientSuspense<T>(options);\n  const value = useMemo<ReplaneContextValue<T>>(() => ({ replane: client }), [client]);\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Provider component that makes a Replane client available to the component tree.\n *\n * Can be used in several ways:\n *\n * 1. With a pre-created client:\n * ```tsx\n * const client = new Replane({ defaults: { ... } });\n * await client.connect({ baseUrl: '...', sdkKey: '...' });\n * <ReplaneProvider client={client}>\n *   <App />\n * </ReplaneProvider>\n * ```\n *\n * 2. With options (client managed internally):\n * ```tsx\n * <ErrorBoundary fallback={<ErrorMessage />}>\n *   <ReplaneProvider\n *     options={{ baseUrl: '...', sdkKey: '...' }}\n *     loader={<LoadingSpinner />}\n *   >\n *     <App />\n *   </ReplaneProvider>\n * </ErrorBoundary>\n * ```\n *\n * 3. With Suspense:\n * ```tsx\n * <ErrorBoundary fallback={<ErrorMessage />}>\n *   <Suspense fallback={<LoadingSpinner />}>\n *     <ReplaneProvider\n *       options={{ baseUrl: '...', sdkKey: '...' }}\n *       suspense\n *     >\n *       <App />\n *     </ReplaneProvider>\n *   </Suspense>\n * </ErrorBoundary>\n * ```\n *\n * 4. With a snapshot (for SSR/hydration):\n * ```tsx\n * // On the server, get a snapshot from the client\n * const snapshot = serverClient.getSnapshot();\n *\n * // On the client, restore from the snapshot with live updates\n * <ReplaneProvider\n *   options={{ baseUrl: '...', sdkKey: '...' }}\n *   snapshot={snapshot}\n * >\n *   <App />\n * </ReplaneProvider>\n * ```\n *\n * Errors during client initialization are thrown during rendering,\n * allowing them to be caught by React Error Boundaries.\n */\nexport function ReplaneProvider<T extends object>(props: ReplaneProviderProps<T>) {\n  if (hasClient(props)) {\n    return <ReplaneProviderWithClient {...props} />;\n  }\n\n  // Has options - check if snapshot is provided\n  if (props.snapshot) {\n    return <ReplaneProviderWithSnapshot {...props} snapshot={props.snapshot} />;\n  }\n\n  if (props.suspense) {\n    return <ReplaneProviderWithSuspense {...props} />;\n  }\n\n  return <ReplaneProviderWithOptions {...props} />;\n}\n","\"use client\";\n\nimport { useCallback, useContext, useSyncExternalStore } from \"react\";\nimport { ReplaneContext } from \"./context\";\nimport type { UntypedReplaneConfig } from \"./types\";\nimport type { Replane, GetConfigOptions } from \"@replanejs/sdk\";\n\nexport function useReplane<T extends object = UntypedReplaneConfig>(): Replane<T> {\n  const context = useContext(ReplaneContext);\n  if (!context) {\n    throw new Error(\"useReplane must be used within a ReplaneProvider\");\n  }\n  return context.replane as Replane<T>;\n}\n\nexport function useConfig<T>(name: string, options?: GetConfigOptions<T>): T {\n  const client = useReplane();\n\n  const subscribe = useCallback(\n    (callback: () => void) => {\n      return client.subscribe(name, callback);\n    },\n    [client, name]\n  );\n\n  const get = useCallback(() => {\n    return client.get(name, options) as T;\n  }, [client, name, options]);\n\n  const value = useSyncExternalStore(subscribe, get, get);\n\n  return value;\n}\n\n/**\n * Creates a typed version of useReplane hook.\n *\n * @example\n * ```tsx\n * interface AppConfigs {\n *   theme: { darkMode: boolean };\n *   features: { beta: boolean };\n * }\n *\n * const useAppReplane = createReplaneHook<AppConfigs>();\n *\n * function MyComponent() {\n *   const replane = useAppReplane();\n *   // replane.get(\"theme\") returns { darkMode: boolean }\n * }\n * ```\n */\nexport function createReplaneHook<TConfigs extends object>() {\n  return function useTypedReplane(): Replane<TConfigs> {\n    return useReplane<TConfigs>();\n  };\n}\n\n/**\n * Creates a typed version of useConfig hook.\n *\n * @example\n * ```tsx\n * interface AppConfigs {\n *   theme: { darkMode: boolean };\n *   features: { beta: boolean };\n * }\n *\n * const useAppConfig = createConfigHook<AppConfigs>();\n *\n * function MyComponent() {\n *   const theme = useAppConfig(\"theme\");\n *   // theme is typed as { darkMode: boolean }\n * }\n * ```\n */\nexport function createConfigHook<TConfigs extends object>() {\n  return function useTypedConfig<K extends keyof TConfigs>(\n    name: K,\n    options?: GetConfigOptions<TConfigs[K]>\n  ): TConfigs[K] {\n    return useConfig<TConfigs[K]>(String(name), options);\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@replanejs/react",
-  "version": "0.8.20",
+  "version": "0.9.0",
   "description": "React SDK for Replane - feature flags and remote configuration",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -40,7 +40,7 @@
     "react": ">=18.0.0"
   },
   "dependencies": {
-    "@replanejs/sdk": "^0.8.20"
+    "@replanejs/sdk": "^0.9.0"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.9.1",