@configdirector/react-native-sdk 0.1.1 → 0.3.0

package/README.md

@@ -1,121 +1,12 @@
 # ConfigDirector React Native SDK
 
-## Getting started
+This is the React Native SDK for [ConfigDirector](https://www.configdirector.com).
 
-### 1. Install
+## Documentation
 
-Install from NPM:
+Refer to the [official documentation for the React Native SDK](https://docs.configdirector.com/sdks/mobile/react-native).
 
-```bash
-npm install --save @configdirector/react-native-sdk
-```
-
-### 2. Initialize the provider using your client SDK key
-
-```tsx
-import { View } from "react-native";
-import AwesomeApp from "./AwesomeApp";
-import { ConfigDirectorProvider } from "@configdirector/react-native-sdk";
-
-export default function App() {
-  return (
-    <ConfigDirectorProvider
-      sdkKey={"YOUR-CLIENT-SDK-KEY"}
-      appName="MyAwesomeApp"
-      appVersion="1.0.0">
-      <View>
-        <AwesomeApp />
-      </View>
-    </ConfigDirectorProvider>
-  );
-}
-```
-
-### 3. Retrieve config values
-
-Retrieve a config value with the `useConfigValue` hook:
-
-```tsx
-import { useConfigValue } from "@configdirector/react-native-sdk";
-
-function MyComponent() {
-  const { value } = useConfigValue<string>("my-config", "default value");
-
-  return <p>My config value: {value}</p>;
-}
-
-export default MyComponent;
-```
-
-You can also determine if the client is still initializing, so rather than transition from the default value to the evaluated value, you can show a loading state until the client is ready and config values are evaluated:
-
-```tsx
-import { useConfigValue } from "@configdirector/react-native-sdk";
-
-function MyComponent() {
-  const { value, loading } = useConfigValue<string>(
-    "my-config",
-    "default value",
-  );
-
-  if (loading) {
-    return <p>Loading...</p>;
-  } else {
-    return <p>My config value: {value}</p>;
-  }
-}
-
-export default MyComponent;
-```
-
-### 4. Updating the user context
-
-Update the user context with the `useConfigDirectorContext` hook:
-
-```tsx
-import {
-  useConfigValue,
-  useConfigDirectorContext,
-} from "@configdirector/react-native-sdk";
-
-function MyComponent() {
-  const { value: myConfigValue } = useConfigValue<string>(
-    "my-config",
-    "default value",
-  );
-  const { updateContext } = useConfigDirectorContext();
-
-  useEffect(() => {
-    updateContext({
-      id: "54321",
-      name: "Another User",
-      traits: { customProperty: "customValue" },
-    });
-  }, []);
-
-  return <p>My config value: {myConfigValue}</p>;
-}
-
-export default MyComponent;
-```
-
-## Requirements
-
-- React Native **0.71 or later** (requires `ReadableStream` support)
-- **Hermes** is strongly recommended. JavaScriptCore (JSC) is supported via a built-in UTF-8 fallback, but Hermes is the default engine in RN 0.70+ and provides better performance.
-
-## Expo
-
-This SDK is compatible with both **Expo managed workflow** and **bare workflow**.
-
-- In the **managed workflow**, Hermes is the default engine — no additional setup needed.
-- In the **bare workflow**, ensure Hermes is enabled in your `Podfile` (iOS) and `gradle.properties` (Android), which is the default in Expo SDK 47+.
-
-Expo SDK 48 (RN 0.71) or later is required.
-
-## License
-
-MIT
+There is also [a quickstart guide for ConfigDirector and any of our SDKs](https://docs.configdirector.com/getting-started/quickstart).
 
 ## Getting Help
 

package/dist/configdirector-react-native.d.mts

@@ -61,6 +61,7 @@ type ConfigDirectorMetaContext = {
   appVersion?: string;
   appName?: string;
 };
+type ConnectionMode = "streaming" | "polling" | "one-time";
 //#endregion
 //#region ../js-client-core/src/types.d.ts
 /**
@@ -76,18 +77,26 @@ type ConfigDirectorClientOptions = {
    */
   connection?: {
     /**
-     * Whether to open a streaming connection or use a one-time pull of configuration state.
-     * If set to true, the streaming connection will remain open and receive updates whenever
+     * The connection mode to be used, one of `streaming` (default), `polling`, or `one-time`.
+     * If set to `streaming`, the connection will remain open and receive updates whenever
      * config state is updated on the ConfigDirector dashboard.
-     * When set to false, there will be an initial request to retrieve config state during
-     * initialization, and an additional request whenever {@link ConfigDirectorClient.updateContext}
-     * is called. But not updates will be received after those requests.
+     * When set to `polling`, there will be an initial request to retrieve config state during
+     * initialization, and additional requests on a `pollingInterval`.
+     * The `one-time` connection mode will only retrieve config state during initialization and
+     * context updates. It will not poll for regular updates.
      *
-     * Defaults to true (streaming connection)
+     * Defaults to `streaming`
      */
-    streaming?: boolean;
+    mode?: ConnectionMode;
     /**
-     * The timeout, in milliseconds, to be used in initialization and when updating the context.
+     * The polling interval in _seconds_ when the `mode` is set to `polling`. This option has no
+     * effect when the `mode` is set to `streaming` or `one-time`.
+     *
+     * Defaults to 60 seconds
+     */
+    pollingInterval?: number;
+    /**
+     * The timeout, in _milliseconds_, to be used in initialization and when updating the context.
      * If streaming is enabled, the operation (initialization or context update) may still succeed
      * after it times out if no unrecoverable errors are encountered (like an invalid SDK key).
      * If streaming is disabled, if the operation times out, it will not be retried.
@@ -123,6 +132,9 @@ type ClientEvents = {
   clientReady: {
     action: ClientConnectAction;
   };
+  contextUpdated: {
+    context: ConfigDirectorContext | undefined;
+  };
 };
 type WatchHandler<T extends ConfigValueType> = (message: T) => void;
 /**
@@ -155,6 +167,15 @@ interface ConfigDirectorClient extends EventProvider<ClientEvents> {
    * @param context The current user's context to be used for evaluating targeting rules (required).
    */
   updateContext(context: ConfigDirectorContext): Promise<void>;
+  /**
+   * Returns the current context the client is configured with, or undefined if there is no context.
+   *
+   * Note that the value returned does not updated immediately after calling {@link updateContext}. Only
+   * once the underlying connection was successful or timed out, the current context is updated. This is
+   * because while the context update is in progress, configs are still evaluated on the previous context.
+   *
+   */
+  get context(): ConfigDirectorContext | undefined;
   /**
    * Returns whether or not the client is ready after calling {@link initialize} or {@link updateContext}
    *
@@ -162,6 +183,11 @@ interface ConfigDirectorClient extends EventProvider<ClientEvents> {
    * was received.
    */
   get isReady(): boolean;
+  /**
+   * Returns whether or not the client is currently initializing. Upon client creation, it is `false`.
+   * It is `true` after calling `initialize` and becomes `false` again once initialization is completed.
+   */
+  get isInitializing(): boolean;
   /**
    * Evaluates a config and returns its value based on the current context and targeting rules
    *
@@ -229,7 +255,7 @@ declare class DefaultConsoleLogger implements ConfigDirectorLogger {
   info(message: string, ...args: any): void;
   warn(message: string, ...args: any): void;
   error(message: string, ...args: any): void;
-  private log;
+  protected log(loggerFunction: (...args: any) => void, level: ConfigDirectorLoggingLevel, message: string, ...args: any): void;
 }
 //#endregion
 //#region src/types.d.ts
@@ -287,10 +313,10 @@ declare const useConfigValue: <T extends ConfigValueType>(key: string, defaultVa
   readyStatus: ClientStatus;
   loading: boolean;
 };
-declare const useConfigDirectorContext: () => {
+declare const useContext: () => {
   updateContext: (context: ConfigDirectorContext) => Promise<void>;
 };
-declare const useConfigDirectorClient: () => {
+declare const useClient: () => {
   client: ConfigDirectorClient;
 };
 //#endregion
@@ -306,4 +332,4 @@ declare class ConfigDirectorReactContextError extends Error {
 //#region src/logger.d.ts
 declare const createConsoleLogger: (level?: ConfigDirectorLoggingLevel) => DefaultConsoleLogger;
 //#endregion
-export { type ClientStatus, type ConfigDirectorClient, type ConfigDirectorClientOptions, type ConfigDirectorContext, type ConfigDirectorLogger, type ConfigDirectorLoggingLevel, ConfigDirectorProvider, type ConfigDirectorProviderOptions, ConfigDirectorReactContextError, type NetInfoSubscribe, createClient, createConsoleLogger, useConfigDirectorClient, useConfigDirectorContext, useConfigValue };
+export { type ClientStatus, type ConfigDirectorClient, type ConfigDirectorClientOptions, type ConfigDirectorContext, type ConfigDirectorLogger, type ConfigDirectorLoggingLevel, ConfigDirectorProvider, type ConfigDirectorProviderOptions, ConfigDirectorReactContextError, type NetInfoSubscribe, createClient, createConsoleLogger, useClient, useConfigValue, useContext };

package/dist/configdirector-react-native.mjs

@@ -1,4 +1,4 @@
-import React, { Component, useContext } from "react";
+import React, { Component, useContext as useContext$1 } from "react";
 import { AppState } from "react-native";
 import { jsx } from "react/jsx-runtime";
 //#region \0@oxc-project+runtime@0.122.0/helpers/typeof.js
@@ -143,8 +143,8 @@ var EventSourceParser = class {
 	constructor(options) {
 		var _options$onEvent;
 		_defineProperty(this, "isFirstChunk", true);
-		_defineProperty(this, "previousIncompleteLine", "");
-		_defineProperty(this, "currentEvent", void 0);
+		_defineProperty(this, "bufferedInput", "");
+		_defineProperty(this, "currentEvent", { data: "" });
 		_defineProperty(this, "lastEventId", void 0);
 		_defineProperty(this, "onEvent", void 0);
 		_defineProperty(this, "onRetry", void 0);
@@ -154,83 +154,95 @@ var EventSourceParser = class {
 		this.onRetry = options.onRetry;
 		this.onComment = options.onComment;
 	}
-	parse(input) {
-		const chunk = this.prepareChunk(input);
-		const lines = this.splitLines(chunk);
-		for (const line of lines) this.parseAndProcessLine(line);
+	parse(chunk) {
+		let input = chunk;
+		if (this.isFirstChunk) {
+			this.isFirstChunk = false;
+			if (input.startsWith("")) input = input.slice(1);
+			else if (input.startsWith("")) input = input.slice(3);
+		}
+		const lines = this.scanLines(this.bufferedInput + input);
+		for (const line of lines) this.dispatchLine(line);
 	}
 	finish() {
-		if (this.previousIncompleteLine !== "") this.parseAndProcessLine(this.previousIncompleteLine);
+		this.bufferedInput = "";
+	}
+	/**
+	* Scans `text` character by character to extract complete lines, recognizing
+	* CR, LF, and CRLF as line terminators per the SSE spec. Any unterminated
+	* trailing text is buffered and prepended to the next chunk.
+	*/
+	scanLines(text) {
+		const lines = [];
+		let lineStart = 0;
+		let i = 0;
+		while (i < text.length) {
+			const ch = text[i];
+			if (ch === "\r" || ch === "\n") {
+				lines.push(text.slice(lineStart, i));
+				if (ch === "\r" && text[i + 1] === "\n") i++;
+				i++;
+				lineStart = i;
+			} else i++;
+		}
+		this.bufferedInput = text.slice(lineStart);
+		return lines;
 	}
-	parseAndProcessLine(line) {
+	dispatchLine(line) {
 		if (line.startsWith(":")) {
 			var _this$onComment;
-			(_this$onComment = this.onComment) === null || _this$onComment === void 0 || _this$onComment.call(this, this.getValueFromLine(0, line));
+			(_this$onComment = this.onComment) === null || _this$onComment === void 0 || _this$onComment.call(this, this.extractValue(line, 1));
 			return;
 		}
 		if (line === "") {
-			this.publishEvent();
+			this.emitEvent();
 			return;
 		}
-		const content = this.parseContentLine(line);
-		this.processContent(content);
+		this.applyField(this.parseField(line));
 	}
-	publishEvent() {
+	emitEvent() {
 		const data = this.currentEvent.data.endsWith("\n") ? this.currentEvent.data.slice(0, -1) : this.currentEvent.data;
-		if (data) this.onEvent({
+		if (data !== "") this.onEvent({
 			...this.currentEvent,
 			id: this.lastEventId,
 			data
 		});
 		this.currentEvent = { data: "" };
 	}
-	processContent(content) {
-		switch (content.field) {
+	applyField(parsed) {
+		switch (parsed.field) {
 			case "event":
-				this.currentEvent.type = content.value;
+				this.currentEvent.type = parsed.value;
 				break;
 			case "data":
-				this.currentEvent.data += content.value + "\n";
+				this.currentEvent.data += parsed.value + "\n";
 				break;
 			case "id":
-				if (!content.value.includes("\0")) this.lastEventId = content.value;
+				if (!parsed.value.includes("\0")) this.lastEventId = parsed.value;
 				break;
 			case "retry":
-				if (/^\d+$/.test(content.value)) {
+				if (/^\d+$/.test(parsed.value)) {
 					var _this$onRetry;
-					(_this$onRetry = this.onRetry) === null || _this$onRetry === void 0 || _this$onRetry.call(this, Number.parseInt(content.value, 10));
+					(_this$onRetry = this.onRetry) === null || _this$onRetry === void 0 || _this$onRetry.call(this, Number.parseInt(parsed.value, 10));
 				}
 				break;
 			default: break;
 		}
 	}
-	parseContentLine(line) {
-		const delimiterIndex = line.indexOf(":");
-		if (delimiterIndex === -1) return {
+	parseField(line) {
+		const colon = line.indexOf(":");
+		if (colon === -1) return {
 			field: line,
 			value: ""
 		};
 		return {
-			field: line.slice(0, delimiterIndex),
-			value: this.getValueFromLine(delimiterIndex, line)
+			field: line.slice(0, colon),
+			value: this.extractValue(line, colon + 1)
 		};
 	}
-	splitLines(chunk) {
-		var _lines$pop;
-		const lines = chunk.split(/\r\n|\r|\n/);
-		this.previousIncompleteLine = (_lines$pop = lines.pop()) !== null && _lines$pop !== void 0 ? _lines$pop : "";
-		return lines;
-	}
-	getValueFromLine(delimiterIndex, line) {
-		if (delimiterIndex === -1) return "";
-		const valueStartIndex = line[delimiterIndex + 1] === " " ? delimiterIndex + 2 : delimiterIndex + 1;
-		return line.slice(valueStartIndex);
-	}
-	prepareChunk(chunk) {
-		if (this.isFirstChunk) {
-			this.isFirstChunk = false;
-			return this.previousIncompleteLine + chunk.replace(/^\xEF\xBB\xBF/, "").replace(/^\uFEFF/, "");
-		} else return this.previousIncompleteLine + chunk;
+	/** Returns the value portion of a line, stripping a single leading space per spec. */
+	extractValue(line, from) {
+		return line[from] === " " ? line.slice(from + 1) : line.slice(from);
 	}
 };
 //#endregion
@@ -273,34 +285,34 @@ var EventSourceClient = class {
 			referrerPolicy: options.referrerPolicy
 		};
 		this._fetch = (_options$fetch = options.fetch) !== null && _options$fetch !== void 0 ? _options$fetch : ((url, init) => fetch(url, init));
-		this._onError = this.getValidatedFunctionOrNoOp(options.onError, "onError");
-		this._onConnect = this.getValidatedFunctionOrNoOp(options.onConnect, "onConnect");
-		this._onDisconnect = this.getValidatedFunctionOrNoOp(options.onDisconnect, "onDisconnect");
-		this._onMessage = this.getValidatedFunctionOrNoOp(options.onMessage, "onMessage");
-		this._onComment = this.getValidatedFunctionOrNoOp(options.onComment, "onComment");
-		this._shouldReconnect = this.getValidatedFunctionOr(options.shouldReconnect, this.DEFAULT_SHOULD_RECONNECT, "shouldReconnect");
-		this._calculateReconnectDelay = this.getValidatedFunctionOr(options.calculateReconnectDelay, this.DEFAULT_CALCULATE_RECONNECT_DELAY, "calculateReconnectDelay");
+		this._onError = this.resolveCallback(options.onError, () => {}, "onError");
+		this._onConnect = this.resolveCallback(options.onConnect, () => {}, "onConnect");
+		this._onDisconnect = this.resolveCallback(options.onDisconnect, () => {}, "onDisconnect");
+		this._onMessage = this.resolveCallback(options.onMessage, () => {}, "onMessage");
+		this._onComment = this.resolveCallback(options.onComment, () => {}, "onComment");
+		this._shouldReconnect = this.resolveCallback(options.shouldReconnect, this.DEFAULT_SHOULD_RECONNECT, "shouldReconnect");
+		this._calculateReconnectDelay = this.resolveCallback(options.calculateReconnectDelay, this.DEFAULT_CALCULATE_RECONNECT_DELAY, "calculateReconnectDelay");
 	}
 	set onError(value) {
-		this._onError = this.getValidatedFunctionOrNoOp(value, "onError");
+		this._onError = this.resolveCallback(value, () => {}, "onError");
 	}
 	set onMessage(value) {
-		this._onMessage = this.getValidatedFunctionOrNoOp(value, "onMessage");
+		this._onMessage = this.resolveCallback(value, () => {}, "onMessage");
 	}
 	set onComment(value) {
-		this._onComment = this.getValidatedFunctionOrNoOp(value, "onComment");
+		this._onComment = this.resolveCallback(value, () => {}, "onComment");
 	}
 	set onConnect(value) {
-		this._onConnect = this.getValidatedFunctionOrNoOp(value, "onConnect");
+		this._onConnect = this.resolveCallback(value, () => {}, "onConnect");
 	}
 	set onDisconnect(value) {
-		this._onDisconnect = this.getValidatedFunctionOrNoOp(value, "onDisconnect");
+		this._onDisconnect = this.resolveCallback(value, () => {}, "onDisconnect");
 	}
 	set shouldReconnect(value) {
-		this._shouldReconnect = this.getValidatedFunctionOr(value, this.DEFAULT_SHOULD_RECONNECT, "shouldReconnect");
+		this._shouldReconnect = this.resolveCallback(value, this.DEFAULT_SHOULD_RECONNECT, "shouldReconnect");
 	}
 	set calculateReconnectDelay(value) {
-		this._calculateReconnectDelay = this.getValidatedFunctionOr(value, this.DEFAULT_CALCULATE_RECONNECT_DELAY, "shouldReconnect");
+		this._calculateReconnectDelay = this.resolveCallback(value, this.DEFAULT_CALCULATE_RECONNECT_DELAY, "shouldReconnect");
 	}
 	get readyState() {
 		return this._readyState;
@@ -310,15 +322,20 @@ var EventSourceClient = class {
 		this.reconnectAttempt = 0;
 		this.initiateConnection();
 	}
+	close() {
+		clearTimeout(this.reconnectTimeout);
+		this._readyState = ReadyState.CLOSED;
+		this.abortController.abort();
+	}
 	initiateConnection() {
 		this.abortController = new AbortController();
 		this._readyState = ReadyState.CONNECTING;
 		this._fetch(this.url, {
 			...this.requestOptions,
-			headers: this.buildHeaders(),
+			headers: this.buildRequestHeaders(),
 			signal: this.abortController.signal,
 			cache: "no-store"
-		}).then(this.handleFetchResponse.bind(this)).catch((error) => {
+		}).then((response) => this.handleFetchResponse(response)).catch((error) => {
 			if (error.name === "AbortError" || this.abortController.signal.aborted) {
 				this.close();
 				return;
@@ -327,23 +344,6 @@ var EventSourceClient = class {
 			this.scheduleReconnect({ error });
 		});
 	}
-	close() {
-		clearTimeout(this.reconnectTimeout);
-		this._readyState = ReadyState.CLOSED;
-		this.abortController.abort();
-	}
-	disconnected() {
-		clearTimeout(this.reconnectTimeout);
-		this._readyState = ReadyState.CLOSED;
-		this._onDisconnect();
-	}
-	buildHeaders() {
-		const lastEventIdHeader = this.lastEventId ? { "Last-Event-ID": this.lastEventId } : void 0;
-		return {
-			...this.headers,
-			...lastEventIdHeader
-		};
-	}
 	async handleFetchResponse(response) {
 		const { body, status } = response;
 		if (status === 204) {
@@ -358,8 +358,6 @@ var EventSourceClient = class {
 		this._readyState = ReadyState.OPEN;
 		this._onConnect();
 		this.reconnectAttempt = 0;
-		const reader = body.getReader();
-		const decoder = new TextDecoder();
 		const parser = new EventSourceParser({
 			onEvent: (event) => {
 				if (typeof event.id === "string") this.lastEventId = event.id;
@@ -368,18 +366,35 @@ var EventSourceClient = class {
 			onComment: (comment) => this._onComment(comment),
 			onRetry: (retryDelay) => this.serverReconnectionTime = retryDelay
 		});
-		let done = false;
-		while (!done) {
-			const { done: readerDone, value } = await reader.read();
-			if (value) parser.parse(decoder.decode(value, { stream: true }));
-			done = readerDone;
-		}
-		parser.finish();
+		await this.readResponseStream(body, parser);
 		this.scheduleReconnect({
 			status,
 			error: new StreamClosedError("The server response stream was closed")
 		});
 	}
+	async readResponseStream(body, parser) {
+		const reader = body.getReader();
+		const decoder = new TextDecoder();
+		let done = false;
+		while (!done) {
+			const result = await reader.read();
+			if (result.value) parser.parse(decoder.decode(result.value, { stream: true }));
+			done = result.done;
+		}
+		parser.finish();
+	}
+	disconnected() {
+		clearTimeout(this.reconnectTimeout);
+		this._readyState = ReadyState.CLOSED;
+		this._onDisconnect();
+	}
+	buildRequestHeaders() {
+		const lastEventIdHeader = this.lastEventId ? { "Last-Event-ID": this.lastEventId } : void 0;
+		return {
+			...this.headers,
+			...lastEventIdHeader
+		};
+	}
 	scheduleReconnect(state) {
 		if (this.abortController.signal.aborted) return;
 		clearTimeout(this.reconnectTimeout);
@@ -390,26 +405,22 @@ var EventSourceClient = class {
 			error: state.error,
 			serverReconnectionTime: this.serverReconnectionTime
 		};
-		if (this._shouldReconnect(reconnectionState)) {
-			this._readyState = ReadyState.CONNECTING;
-			let delay = this._calculateReconnectDelay(reconnectionState);
-			if (!Number.isFinite(delay) || delay < 1 || delay > 1e3 * 60 * 60) {
-				this._onError(new ValueOutOfRangeError(`The calculated reconnect delay is out of range: ${delay}. Defaulting to ${this.serverReconnectionTime}`));
-				delay = this.serverReconnectionTime;
-			}
-			this.reconnectTimeout = setTimeout(() => this.initiateConnection(), delay);
-		} else {
+		if (!this._shouldReconnect(reconnectionState)) {
 			this.disconnected();
 			return;
 		}
+		this._readyState = ReadyState.CONNECTING;
+		let delay = this._calculateReconnectDelay(reconnectionState);
+		if (!Number.isFinite(delay) || delay < 1 || delay > 1e3 * 60 * 60) {
+			this._onError(new ValueOutOfRangeError(`The calculated reconnect delay is out of range: ${delay}. Defaulting to ${this.serverReconnectionTime}`));
+			delay = this.serverReconnectionTime;
+		}
+		this.reconnectTimeout = setTimeout(() => this.initiateConnection(), delay);
 	}
-	getValidatedFunctionOrNoOp(func, name) {
-		return this.getValidatedFunctionOr(func, () => {}, name);
-	}
-	getValidatedFunctionOr(func, defaultFunc, name) {
-		if (func == null) return defaultFunc;
-		else if (typeof func === "function") return func;
-		else throw new InvalidOptionError(`${name} must be a function`);
+	resolveCallback(provided, fallback, optionName) {
+		if (provided == null) return fallback;
+		if (typeof provided !== "function") throw new InvalidOptionError(`${optionName} must be a function`);
+		return provided;
 	}
 };
 //#endregion
@@ -668,6 +679,61 @@ const createDefaultLogger = (level, messageDecorator) => {
 	return new DefaultConsoleLogger(level !== null && level !== void 0 ? level : "warn", messageDecorator !== null && messageDecorator !== void 0 ? messageDecorator : new LogMessageDecorator());
 };
 //#endregion
+//#region ../shared/src/transport/AbstractPollingTransport.ts
+var AbstractPollingTransport = class {
+	constructor() {
+		_defineProperty(this, "fatalError", false);
+		_defineProperty(this, "pollingInterval", void 0);
+		_defineProperty(this, "pollingIntervalSeconds", 60);
+	}
+	clearPollingInterval() {
+		clearInterval(this.pollingInterval);
+	}
+	schedulePollingInterval(callback) {
+		clearInterval(this.pollingInterval);
+		if (this.pollingIntervalSeconds <= 0) return;
+		this.pollingInterval = setInterval(callback, this.pollingIntervalSeconds * 1e3);
+	}
+	async handleNonOkResponse(response) {
+		if (!response.ok) if (this.isStatusFatal(response.status)) {
+			this.fatalError = true;
+			throw this.prepareFatalResponseStatusError(response.status, await response.text());
+		} else throw new ConfigDirectorConnectionError(`Connection failed with status: ${response.status}`, response.status);
+	}
+	handleFetchError(fetchError) {
+		if (this.isFetchErrorFatal(fetchError)) {
+			this.fatalError = true;
+			this.close();
+			throw new ConfigDirectorConnectionError(`Connection failed with fatal error: ${fetchError}. This is an unrecoverable error, retry attempts will be ignored.`);
+		} else if (fetchError instanceof SyntaxError) throw new ConfigDirectorConnectionError(`Failed to parse the response from the server: ${fetchError}`);
+		else throw new ConfigDirectorConnectionError(`Connection failed with error: ${fetchError}.`);
+	}
+	prepareFatalResponseStatusError(responseStatus, errorBody) {
+		var _errorBody$trim$lengt, _errorBody$trim;
+		const status = responseStatus !== null && responseStatus !== void 0 ? responseStatus : 0;
+		return new ConfigDirectorConnectionError(`${`Connection failed with status: ${responseStatus !== null && responseStatus !== void 0 ? responseStatus : "unknown"}`}${((_errorBody$trim$lengt = errorBody === null || errorBody === void 0 || (_errorBody$trim = errorBody.trim()) === null || _errorBody$trim === void 0 ? void 0 : _errorBody$trim.length) !== null && _errorBody$trim$lengt !== void 0 ? _errorBody$trim$lengt : 0) > 0 ? ` (${errorBody})` : ""}. This is an unrecoverable error, retry attempts will be ignored.`, status);
+	}
+	isStatusFatal(status) {
+		return !!status && status >= 400 && status < 500;
+	}
+	isFetchErrorFatal(fetchError) {
+		if ((fetchError === null || fetchError === void 0 ? void 0 : fetchError.name) === "NotAllowedError") return true;
+		else if (fetchError instanceof TypeError) return true;
+		return false;
+	}
+	get isConnected() {
+		return this.pollingInterval !== void 0;
+	}
+	close() {
+		clearInterval(this.pollingInterval);
+		this.pollingInterval = void 0;
+	}
+	dispose() {
+		this.close();
+		this.clear();
+	}
+};
+//#endregion
 //#region ../shared/src/fetchWithTimeout.ts
 const fetchWithTimeout = async (timeout, resource, options, logger) => {
 	const abortController = new AbortController();
@@ -689,22 +755,35 @@ const fetchWithTimeout = async (timeout, resource, options, logger) => {
 	}
 };
 //#endregion
-//#region ../js-client-core/src/PullTransport.ts
-var PullTransport = class {
+//#region ../js-client-core/src/PollingTransport.ts
+var PollingTransport = class extends AbstractPollingTransport {
 	constructor(options) {
+		var _options$pollingInter;
+		super();
 		this.options = options;
 		_defineProperty(this, "logger", void 0);
 		_defineProperty(this, "eventEmitter", new Emitter());
 		_defineProperty(this, "url", void 0);
-		_defineProperty(this, "fatalError", false);
+		_defineProperty(this, "lastUpdateTimestamp", void 0);
 		this.options = options;
 		this.logger = options.logger;
-		this.url = options.resolveUrl("client/pull/v1", options.baseUrl);
+		this.url = options.resolveUrl("client/polling/v1", options.baseUrl);
+		this.pollingIntervalSeconds = (_options$pollingInter = options.pollingInterval) !== null && _options$pollingInter !== void 0 ? _options$pollingInter : 60;
 	}
 	async connect(context, timeout) {
+		this.clearPollingInterval();
+		await this.fetchConfigs(context, timeout);
+		this.schedulePollingInterval(() => {
+			this.fetchConfigs(context, timeout).catch((error) => {
+				this.logger.error("[PollingTransport] Error during polling:", error);
+			});
+		});
+		return this;
+	}
+	async fetchConfigs(context, timeout) {
 		if (this.fatalError) {
-			this.logger.warn("[PullTransport] There was a prior unrecoverable error. Ignoring attempt to reconnect.");
-			return this;
+			this.logger.warn("[PollingTransport] There was a prior unrecoverable error. Ignoring attempt to reconnect.");
+			return;
 		}
 		try {
 			const response = await fetchWithTimeout(timeout, this.url, {
@@ -713,32 +792,20 @@ var PullTransport = class {
 				body: JSON.stringify({
 					givenContext: context,
 					metaContext: this.options.metaContext,
-					clientSdkKey: this.options.clientSdkKey
+					clientSdkKey: this.options.clientSdkKey,
+					lastUpdateTimestamp: this.lastUpdateTimestamp
 				})
 			}, this.logger);
-			if (!response.ok) if (this.isStatusFatal(response.status)) {
-				this.fatalError = true;
-				throw this.prepareFatalResponseStatusError(response.status, await response.text());
-			} else throw new ConfigDirectorConnectionError(`Connection failed with status: ${response.status}`, response.status);
-			const json = JSON.parse(await response.text());
-			this.eventEmitter.emit("configSetReceived", json);
-			return this;
+			await this.handleNonOkResponse(response);
+			if (response.status == 200) {
+				const json = JSON.parse(await response.text());
+				this.lastUpdateTimestamp = json.timestamp;
+				this.eventEmitter.emit("configSetReceived", json);
+			}
 		} catch (fetchError) {
-			if (isFetchErrorFatal(fetchError)) {
-				this.fatalError = true;
-				throw new ConfigDirectorConnectionError(`Connection failed with fatal error: ${fetchError}. This is an unrecoverable error, retry attempts will be ignored.`);
-			} else if (fetchError instanceof SyntaxError) throw new ConfigDirectorConnectionError(`Failed to parse the response from the server: ${fetchError}`);
-			else throw new ConfigDirectorConnectionError(`Connection failed with error: ${fetchError}.`);
+			this.handleFetchError(fetchError);
 		}
 	}
-	prepareFatalResponseStatusError(responseStatus, errorBody) {
-		var _errorBody$trim$lengt, _errorBody$trim;
-		const status = responseStatus !== null && responseStatus !== void 0 ? responseStatus : 0;
-		return new ConfigDirectorConnectionError(`${`Connection failed with status: ${responseStatus !== null && responseStatus !== void 0 ? responseStatus : "unknown"}`}${((_errorBody$trim$lengt = errorBody === null || errorBody === void 0 || (_errorBody$trim = errorBody.trim()) === null || _errorBody$trim === void 0 ? void 0 : _errorBody$trim.length) !== null && _errorBody$trim$lengt !== void 0 ? _errorBody$trim$lengt : 0) > 0 ? ` (${errorBody})` : ""}. This is an unrecoverable error, retry attempts will be ignored.`, status);
-	}
-	isStatusFatal(status) {
-		return !!status && status >= 400 && status < 500;
-	}
 	on(name, handler) {
 		this.eventEmitter.on(name, handler);
 	}
@@ -748,10 +815,13 @@ var PullTransport = class {
 	clear() {
 		this.eventEmitter.clear();
 	}
-	close() {}
-	dispose() {
-		this.close();
-		this.clear();
+};
+//#endregion
+//#region ../js-client-core/src/OneTimeTransport.ts
+var OneTimeTransport = class extends PollingTransport {
+	constructor(options) {
+		super(options);
+		this.pollingIntervalSeconds = 0;
 	}
 };
 //#endregion
@@ -765,7 +835,7 @@ const CLIENT_BASE_URL = "https://client-sdk-api.configdirector.com";
 const MAX_EXPONENTIAL_DELAY = 9;
 var DefaultConfigDirectorClient = class {
 	constructor(telemetryClient, clientSdkKey, sdkOptions, clientOptions, internalClientOptions) {
-		var _clientOptions$logger, _clientOptions$connec, _clientOptions$connec2, _internalClientOption, _this$parseUrl, _clientOptions$connec3, _clientOptions$connec4, _navigator, _internalClientOption2;
+		var _clientOptions$logger, _clientOptions$connec, _clientOptions$connec2, _internalClientOption, _this$parseUrl, _clientOptions$connec3, _clientOptions$connec4, _clientOptions$connec5, _navigator, _internalClientOption2, _clientOptions$connec6;
 		_defineProperty(this, "logger", void 0);
 		_defineProperty(this, "telemetryClient", void 0);
 		_defineProperty(this, "configSet", void 0);
@@ -775,16 +845,17 @@ var DefaultConfigDirectorClient = class {
 		_defineProperty(this, "timeout", void 0);
 		_defineProperty(this, "timeoutTimer", void 0);
 		_defineProperty(this, "ready", false);
+		_defineProperty(this, "initializing", false);
 		_defineProperty(this, "readyPromise", void 0);
 		_defineProperty(this, "readyResolve", void 0);
 		_defineProperty(this, "currentContext", void 0);
-		_defineProperty(this, "streaming", void 0);
+		_defineProperty(this, "connectionMode", void 0);
 		this.logger = (_clientOptions$logger = clientOptions === null || clientOptions === void 0 ? void 0 : clientOptions.logger) !== null && _clientOptions$logger !== void 0 ? _clientOptions$logger : createDefaultLogger();
 		this.timeout = (_clientOptions$connec = clientOptions === null || clientOptions === void 0 || (_clientOptions$connec2 = clientOptions.connection) === null || _clientOptions$connec2 === void 0 ? void 0 : _clientOptions$connec2.timeout) !== null && _clientOptions$connec !== void 0 ? _clientOptions$connec : 3e3;
 		const urlFactory = (_internalClientOption = internalClientOptions === null || internalClientOptions === void 0 ? void 0 : internalClientOptions.urlFactory) !== null && _internalClientOption !== void 0 ? _internalClientOption : defaultUrlFactory;
 		const baseUrl = (_this$parseUrl = this.parseUrl(clientOptions === null || clientOptions === void 0 || (_clientOptions$connec3 = clientOptions.connection) === null || _clientOptions$connec3 === void 0 ? void 0 : _clientOptions$connec3.url, urlFactory)) !== null && _this$parseUrl !== void 0 ? _this$parseUrl : CLIENT_BASE_URL;
-		this.streaming = (clientOptions === null || clientOptions === void 0 || (_clientOptions$connec4 = clientOptions.connection) === null || _clientOptions$connec4 === void 0 ? void 0 : _clientOptions$connec4.streaming) === false ? false : true;
-		const transportConstructor = this.streaming ? StreamingTransport : PullTransport;
+		this.connectionMode = (_clientOptions$connec4 = clientOptions === null || clientOptions === void 0 || (_clientOptions$connec5 = clientOptions.connection) === null || _clientOptions$connec5 === void 0 ? void 0 : _clientOptions$connec5.mode) !== null && _clientOptions$connec4 !== void 0 ? _clientOptions$connec4 : "streaming";
+		const transportConstructor = this.getTransportConstructor(this.connectionMode);
 		this.telemetryClient = telemetryClient;
 		this.transport = new transportConstructor({
 			clientSdkKey,
@@ -800,7 +871,8 @@ var DefaultConfigDirectorClient = class {
 			fetch: internalClientOptions === null || internalClientOptions === void 0 ? void 0 : internalClientOptions.fetch,
 			connectionRetryDelay: (_internalClientOption2 = internalClientOptions === null || internalClientOptions === void 0 ? void 0 : internalClientOptions.connectionRetryDelay) !== null && _internalClientOption2 !== void 0 ? _internalClientOption2 : ((attempt) => {
 				return Math.pow(2, Math.min(attempt, MAX_EXPONENTIAL_DELAY)) * 1e3;
-			})
+			}),
+			pollingInterval: clientOptions === null || clientOptions === void 0 || (_clientOptions$connec6 = clientOptions.connection) === null || _clientOptions$connec6 === void 0 ? void 0 : _clientOptions$connec6.pollingInterval
 		});
 		this.transport.on("configSetReceived", (configSet) => {
 			var _this$readyResolve;
@@ -821,12 +893,23 @@ var DefaultConfigDirectorClient = class {
 			this.logger.debug("[ConfigDirectorClient] ConfigSet updated from server:", { keys: configKeys });
 		});
 	}
+	getTransportConstructor(connectionMode) {
+		switch (connectionMode) {
+			case "one-time": return OneTimeTransport;
+			case "polling": return PollingTransport;
+			default: return StreamingTransport;
+		}
+	}
 	async initialize(context) {
+		this.initializing = true;
 		await this.connectToTransport(context, "initialization");
 	}
 	async updateContext(context) {
 		await this.connectToTransport(context, "context update");
 	}
+	get context() {
+		return this.currentContext;
+	}
 	async connectToTransport(context, caller) {
 		try {
 			this.ready = false;
@@ -834,6 +917,7 @@ var DefaultConfigDirectorClient = class {
 				this.readyResolve = resolve;
 			}).then(() => {
 				this.ready = true;
+				this.initializing = false;
 				this.eventEmitter.emit("clientReady", { action: caller });
 				this.logger.debug("[ConfigDirectorClient] Received initial payload from the server, client is ready");
 			});
@@ -841,6 +925,7 @@ var DefaultConfigDirectorClient = class {
 			await this.transport.connect(context !== null && context !== void 0 ? context : {}, this.timeout);
 			this.currentContext = context;
 			this.telemetryClient.updateContext(context);
+			this.eventEmitter.emit("contextUpdated", { context });
 			const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - startTime;
 			const remainingTimeout = this.timeout - elapsedTime;
 			clearTimeout(this.timeoutTimer);
@@ -848,10 +933,7 @@ var DefaultConfigDirectorClient = class {
 			if (remainingTimeout > 0) await Promise.race([this.readyPromise, new Promise((resolve) => {
 				this.timeoutTimer = setTimeout(() => resolve(), remainingTimeout);
 			})]).finally(() => clearTimeout(this.timeoutTimer));
-			if (!this.ready) {
-				const warningDetails = this.streaming ? "The client will continue to retry since there were no fatal errors detected. Configs will return the default value until the connection succeeds." : "Since the client was configured without streaming, configs may not update and always return the default value.";
-				this.logger.warn(`[ConfigDirectorClient] Timed out waiting for ${caller} after ${this.timeout}ms. ${warningDetails}`);
-			}
+			if (!this.ready) this.logger.warn(`[ConfigDirectorClient] Timed out waiting for ${caller} after ${this.timeout}ms. The client will continue to retry since there were no fatal errors detected. Configs will return the default value until the connection succeeds.`);
 		} catch (error) {
 			this.logger.error(`[ConfigDirectorClient] An error occurred during ${caller}: `, error);
 		}
@@ -936,6 +1018,9 @@ var DefaultConfigDirectorClient = class {
 	get isReady() {
 		return this.ready;
 	}
+	get isInitializing() {
+		return this.initializing;
+	}
 	on(eventName, handler) {
 		this.eventEmitter.on(eventName, handler);
 	}
@@ -1243,89 +1328,119 @@ const createConsoleLogger = (level) => createDefaultLogger(level, new MessageDec
 //#endregion
 //#region src/utf8Encoder.ts
 /**
-* Encodes a string to UTF-8 bytes. Uses the native TextEncoder when available
-* (Hermes), and falls back to an encodeURIComponent-based approach for JSC.
+* Encodes a string to a UTF-8 byte sequence.
+*
+* Uses the native TextEncoder when available (Hermes runtime). For environments
+* that lack it (JSC), falls back to a manual implementation that follows the
+* UTF-8 encoding algorithm from the Unicode standard:
+*
+*   U+0000–U+007F    →  1 byte   0xxxxxxx
+*   U+0080–U+07FF    →  2 bytes  110xxxxx 10xxxxxx
+*   U+0800–U+FFFF    →  3 bytes  1110xxxx 10xxxxxx 10xxxxxx
+*   U+10000–U+10FFFF →  4 bytes  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+*
+* JavaScript strings are UTF-16, so code points above U+FFFF are stored as
+* surrogate pairs and must be recombined before encoding.
 */
 const encodeUtf8 = (str) => {
-	if (typeof globalThis["TextEncoder"] === "function") return new TextEncoder().encode(str);
-	const uri = encodeURIComponent(str);
+	if (typeof TextEncoder === "function") return new TextEncoder().encode(str);
+	return encodeManually(str);
+};
+const encodeManually = (str) => {
 	const bytes = [];
-	for (let i = 0; i < uri.length;) if (uri[i] === "%") {
-		bytes.push(parseInt(uri.slice(i + 1, i + 3), 16));
-		i += 3;
-	} else {
-		bytes.push(uri.charCodeAt(i));
-		i++;
+	let i = 0;
+	while (i < str.length) {
+		let cp = str.charCodeAt(i++);
+		if (cp >= 55296 && cp <= 56319 && i < str.length) {
+			const low = str.charCodeAt(i);
+			if (low >= 56320 && low <= 57343) {
+				cp = 65536 + (cp - 55296 << 10) + (low - 56320);
+				i++;
+			}
+		}
+		if (cp <= 127) bytes.push(cp);
+		else if (cp <= 2047) bytes.push(192 | cp >> 6, 128 | cp & 63);
+		else if (cp <= 65535) bytes.push(224 | cp >> 12, 128 | cp >> 6 & 63, 128 | cp & 63);
+		else bytes.push(240 | cp >> 18, 128 | cp >> 12 & 63, 128 | cp >> 6 & 63, 128 | cp & 63);
 	}
 	return new Uint8Array(bytes);
 };
 //#endregion
 //#region src/reactNativeStreamingFetch.ts
+const abortError = (message) => {
+	const err = new Error(message);
+	err.name = "AbortError";
+	return err;
+};
 /**
-* A fetch-compatible function for React Native that uses XMLHttpRequest to support
-* streaming SSE responses. React Native's built-in fetch buffers the entire response
-* body before resolving, which means it never resolves for persistent SSE connections.
-* XHR's onprogress callback fires incrementally as data arrives.
+* A fetch-compatible function for React Native that uses XMLHttpRequest to
+* support streaming SSE responses. React Native's built-in fetch accumulates
+* the entire response body before resolving, so persistent SSE connections
+* never complete. XHR's progress events fire incrementally as data arrives,
+* which we forward into a ReadableStream.
 */
 const reactNativeStreamingFetch = (url, init) => {
 	var _init$signal;
-	if ((_init$signal = init.signal) === null || _init$signal === void 0 ? void 0 : _init$signal.aborted) return Promise.reject(new DOMException("The operation was aborted.", "AbortError"));
+	if ((_init$signal = init.signal) === null || _init$signal === void 0 ? void 0 : _init$signal.aborted) return Promise.reject(abortError("Request was aborted before it was opened"));
 	return new Promise((resolve, reject) => {
 		var _init$method, _ref;
 		const xhr = new XMLHttpRequest();
 		xhr.open((_init$method = init.method) !== null && _init$method !== void 0 ? _init$method : "GET", url);
-		const headers = init.headers;
-		if (headers) for (const [key, value] of Object.entries(headers)) xhr.setRequestHeader(key, value);
-		let resolved = false;
-		let lastLength = 0;
-		let controller;
-		const stream = new ReadableStream({ start(c) {
-			controller = c;
+		const requestHeaders = init.headers;
+		if (requestHeaders) for (const [name, value] of Object.entries(requestHeaders)) xhr.setRequestHeader(name, value);
+		let responseResolved = false;
+		let bytesForwarded = 0;
+		let streamController;
+		const responseBody = new ReadableStream({ start(ctrl) {
+			streamController = ctrl;
 		} });
+		const flushNewBytes = () => {
+			const next = xhr.responseText.slice(bytesForwarded);
+			if (next.length > 0) {
+				bytesForwarded += next.length;
+				streamController.enqueue(encodeUtf8(next));
+			}
+		};
 		xhr.onreadystatechange = () => {
-			if (xhr.readyState === XMLHttpRequest.HEADERS_RECEIVED && !resolved) {
-				resolved = true;
-				const headers = new Headers();
-				xhr.getAllResponseHeaders().trim().split(/\r?\n/).forEach((line) => {
-					const [key, ...rest] = line.split(": ");
-					if (key) headers.set(key, rest.join(": "));
-				});
+			if (xhr.readyState >= XMLHttpRequest.HEADERS_RECEIVED && !responseResolved) {
+				responseResolved = true;
 				resolve({
 					status: xhr.status,
-					headers,
-					body: stream
+					headers: parseHeaders(xhr.getAllResponseHeaders()),
+					body: responseBody
 				});
 			}
 		};
 		xhr.onprogress = () => {
-			const newText = xhr.responseText.slice(lastLength);
-			lastLength = xhr.responseText.length;
-			if (newText) controller.enqueue(encodeUtf8(newText));
+			flushNewBytes();
 		};
 		xhr.onload = () => {
-			const remaining = xhr.responseText.slice(lastLength);
-			if (remaining) controller.enqueue(encodeUtf8(remaining));
-			controller.close();
+			flushNewBytes();
+			streamController.close();
 		};
 		xhr.onerror = () => {
-			const error = /* @__PURE__ */ new TypeError("Network request failed");
-			if (!resolved) reject(error);
-			else controller.error(error);
-			xhr.abort();
+			const err = /* @__PURE__ */ new TypeError("Network request failed");
+			if (!responseResolved) reject(err);
+			else streamController.error(err);
 		};
 		if (init.signal) init.signal.addEventListener("abort", () => {
 			xhr.abort();
-			if (!resolved) {
-				const abortError = /* @__PURE__ */ new Error("The operation was aborted.");
-				abortError.name = "AbortError";
-				reject(abortError);
-			} else try {
-				controller.close();
+			if (!responseResolved) reject(abortError("Request was aborted"));
+			else try {
+				streamController.close();
 			} catch {}
 		});
 		xhr.send((_ref = init.body) !== null && _ref !== void 0 ? _ref : null);
 	});
 };
+const parseHeaders = (raw) => {
+	const headers = new Headers();
+	for (const line of raw.trim().split(/\r?\n/)) {
+		const sep = line.indexOf(": ");
+		if (sep > 0) headers.set(line.slice(0, sep), line.slice(sep + 2));
+	}
+	return headers;
+};
 //#endregion
 //#region src/ReactNativeTelemetryClient.ts
 var ReactNativeTelemetryClient = class {
@@ -1377,7 +1492,7 @@ const createClient = (clientSdkKey, clientOptions) => {
 	const logger = (_clientOptions$logger = clientOptions === null || clientOptions === void 0 ? void 0 : clientOptions.logger) !== null && _clientOptions$logger !== void 0 ? _clientOptions$logger : createConsoleLogger("warn");
 	return new DefaultConfigDirectorClient(new ReactNativeTelemetryClient(clientSdkKey, (clientOptions === null || clientOptions === void 0 || (_clientOptions$connec = clientOptions.connection) === null || _clientOptions$connec === void 0 ? void 0 : _clientOptions$connec.url) ? urlFactory(clientOptions.connection.url) : CLIENT_BASE_URL, logger, urlFactory), clientSdkKey, {
 		sdkName: "react-native-sdk",
-		sdkVersion: "0.1.1"
+		sdkVersion: "0.3.0"
 	}, {
 		...clientOptions,
 		logger
@@ -1481,7 +1596,7 @@ const noContextError = () => {
 	return new ConfigDirectorReactContextError("The ConfigDirector client was not found in the React context. Please make sure the component using this hook is inside the context of a ConfigDirectorProvider.");
 };
 const useConfigValue = (key, defaultValue) => {
-	const configDirectorReactContext = useContext(reactContext);
+	const configDirectorReactContext = useContext$1(reactContext);
 	if (!(configDirectorReactContext === null || configDirectorReactContext === void 0 ? void 0 : configDirectorReactContext.client)) throw noContextError();
 	return {
 		value: configDirectorReactContext.client.getValue(key, defaultValue),
@@ -1489,8 +1604,8 @@ const useConfigValue = (key, defaultValue) => {
 		loading: configDirectorReactContext.status === "loading"
 	};
 };
-const useConfigDirectorContext = () => {
-	const configDirectorReactContext = useContext(reactContext);
+const useContext = () => {
+	const configDirectorReactContext = useContext$1(reactContext);
 	if (!(configDirectorReactContext === null || configDirectorReactContext === void 0 ? void 0 : configDirectorReactContext.client)) throw noContextError();
 	const updateContext = async (context) => {
 		var _configDirectorReactC;
@@ -1498,10 +1613,10 @@ const useConfigDirectorContext = () => {
 	};
 	return { updateContext };
 };
-const useConfigDirectorClient = () => {
-	const configDirectorReactContext = useContext(reactContext);
+const useClient = () => {
+	const configDirectorReactContext = useContext$1(reactContext);
 	if (!(configDirectorReactContext === null || configDirectorReactContext === void 0 ? void 0 : configDirectorReactContext.client)) throw noContextError();
 	return { client: configDirectorReactContext.client };
 };
 //#endregion
-export { ConfigDirectorProvider, ConfigDirectorReactContextError, createClient, createConsoleLogger, useConfigDirectorClient, useConfigDirectorContext, useConfigValue };
+export { ConfigDirectorProvider, ConfigDirectorReactContextError, createClient, createConsoleLogger, useClient, useConfigValue, useContext };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@configdirector/react-native-sdk",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "React Native client SDK for ConfigDirector. ConfigDirector is a remote configuration and feature flag service.",
   "license": "MIT",
   "author": "ConfigDirector",
@@ -21,7 +21,7 @@
   "homepage": "https://www.configdirector.com",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ConfigDirector/js-sdks"
+    "url": "git+https://github.com/ConfigDirector/js-sdks.git"
   },
   "main": "./dist/configdirector-react-native.mjs",
   "types": "./dist/configdirector-react-native.d.mts",
@@ -39,7 +39,7 @@
   ],
   "scripts": {
     "example": "yarn workspace @configdirector/react-native-sdk-example",
-    "clean": "del-cli dist",
+    "clean": "rm -fr dist",
     "build": "tsdown",
     "prepare": "yarn build",
     "typecheck": "tsc",
@@ -78,9 +78,9 @@
     "wtfnode": "^0.10.1"
   },
   "peerDependencies": {
-    "expo": ">=48",
+    "expo": ">=52",
     "react": "*",
-    "react-native": ">=0.71"
+    "react-native": ">=0.75"
   },
   "peerDependenciesMeta": {
     "expo": {