@configdirector/react-native-sdk 0.1.0 → 0.2.0

package/README.md

@@ -10,15 +10,94 @@ Install from NPM:
 npm install --save @configdirector/react-native-sdk
 ```
 
+### 2. Initialize the provider using your client SDK key
 
-## Usage
+```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 { createClient } from "@configdirector/react-native-sdk";
+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 `useContext` hook:
+
+```tsx
+import {
+  useConfigValue,
+  useContext,
+} from "@configdirector/react-native-sdk";
+
+function MyComponent() {
+  const { value: myConfigValue } = useConfigValue<string>(
+    "my-config",
+    "default value",
+  );
+  const { updateContext } = useContext();
+
+  useEffect(() => {
+    updateContext({
+      id: "54321",
+      name: "Another User",
+      traits: { customProperty: "customValue" },
+    });
+  }, []);
+
+  return <p>My config value: {myConfigValue}</p>;
+}
+
+export default MyComponent;
+```
 
 ## Requirements
 
@@ -37,3 +116,7 @@ Expo SDK 48 (RN 0.71) or later is required.
 ## License
 
 MIT
+
+## Getting Help
+
+Reach out to us via https://www.configdirector.com/support

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

@@ -123,6 +123,9 @@ type ClientEvents = {
   clientReady: {
     action: ClientConnectAction;
   };
+  contextUpdated: {
+    context: ConfigDirectorContext | undefined;
+  };
 };
 type WatchHandler<T extends ConfigValueType> = (message: T) => void;
 /**
@@ -155,6 +158,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 +174,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
    *
@@ -287,10 +304,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 +323,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
@@ -775,6 +786,7 @@ 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);
@@ -822,11 +834,15 @@ var DefaultConfigDirectorClient = class {
 		});
 	}
 	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 +850,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 +858,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);
@@ -936,6 +954,9 @@ var DefaultConfigDirectorClient = class {
 	get isReady() {
 		return this.ready;
 	}
+	get isInitializing() {
+		return this.initializing;
+	}
 	on(eventName, handler) {
 		this.eventEmitter.on(eventName, handler);
 	}
@@ -1243,89 +1264,114 @@ 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
 /**
-* 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(new DOMException("Request was aborted before it was opened", "AbortError"));
 	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(new DOMException("Request was aborted", "AbortError"));
+			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 +1423,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.0"
+		sdkVersion: "0.2.0"
 	}, {
 		...clientOptions,
 		logger
@@ -1481,7 +1527,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 +1535,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 +1544,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.0",
+  "version": "0.2.0",
   "description": "React Native client SDK for ConfigDirector. ConfigDirector is a remote configuration and feature flag service.",
   "license": "MIT",
   "author": "ConfigDirector",