@configdirector/react-native-sdk 0.1.0

package/dist/configdirector-react-native.mjs

@@ -0,0 +1,1507 @@
+import React, { Component, useContext } from "react";
+import { AppState } from "react-native";
+import { jsx } from "react/jsx-runtime";
+//#region \0@oxc-project+runtime@0.122.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region ../js-client-core/src/Emitter.ts
+var Emitter = class {
+	constructor() {
+		_defineProperty(this, "handlerMap", /* @__PURE__ */ new Map());
+	}
+	on(name, handler) {
+		const handlers = this.handlerMap.get(name);
+		if (handlers) handlers.push(handler);
+		else this.handlerMap.set(name, [handler]);
+	}
+	once(name, handler) {
+		const self = this;
+		function onceHandler(payload) {
+			self.off(name, onceHandler);
+			handler.apply(self, payload);
+		}
+		this.on(name, onceHandler);
+	}
+	off(name, handler) {
+		const handlers = this.handlerMap.get(name);
+		if (!handlers) return;
+		if (handler) {
+			const listenerIndex = handlers.indexOf(handler);
+			if (listenerIndex >= 0) handlers.splice(listenerIndex, 1);
+		} else this.handlerMap.set(name, []);
+	}
+	clear() {
+		this.handlerMap.clear();
+	}
+	emit(name, payload) {
+		const handlers = this.handlerMap.get(name);
+		if (!handlers) return;
+		handlers.slice().map((h) => h(payload));
+	}
+};
+//#endregion
+//#region ../shared/src/errors.ts
+var ConfigDirectorConnectionError = class ConfigDirectorConnectionError extends Error {
+	constructor(message, status) {
+		super(message);
+		_defineProperty(this, "name", "ConfigDirectorConnectionError");
+		_defineProperty(this, "status", void 0);
+		this.status = status;
+		Object.setPrototypeOf(this, ConfigDirectorConnectionError.prototype);
+	}
+};
+var ConfigDirectorValidationError = class ConfigDirectorValidationError extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "name", "ConfigDirectorValidationError");
+		Object.setPrototypeOf(this, ConfigDirectorValidationError.prototype);
+	}
+};
+//#endregion
+//#region ../js-client-core/src/errors.ts
+const isFetchErrorFatal = (fetchError) => {
+	if ((fetchError === null || fetchError === void 0 ? void 0 : fetchError.name) === "NotAllowedError") return true;
+	else if (fetchError instanceof TypeError) return true;
+	return false;
+};
+//#endregion
+//#region ../eventsource/src/errors.ts
+var StreamClosedError = class StreamClosedError extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "name", "StreamClosedError");
+		Object.setPrototypeOf(this, StreamClosedError.prototype);
+	}
+};
+var MissingResponseBodyError = class MissingResponseBodyError extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "name", "MissingResponseBodyError");
+		Object.setPrototypeOf(this, MissingResponseBodyError.prototype);
+	}
+};
+var InvalidOptionError = class InvalidOptionError extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "name", "InvalidOptionError");
+		Object.setPrototypeOf(this, InvalidOptionError.prototype);
+	}
+};
+var ValueOutOfRangeError = class ValueOutOfRangeError extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "name", "ValueOutOfRangeError");
+		Object.setPrototypeOf(this, ValueOutOfRangeError.prototype);
+	}
+};
+//#endregion
+//#region ../eventsource/src/types.ts
+let ReadyState = /* @__PURE__ */ function(ReadyState) {
+	ReadyState["OPEN"] = "open";
+	ReadyState["CLOSED"] = "closed";
+	ReadyState["CONNECTING"] = "connecting";
+	return ReadyState;
+}({});
+//#endregion
+//#region ../eventsource/src/EventSourceParser.ts
+var EventSourceParser = class {
+	constructor(options) {
+		var _options$onEvent;
+		_defineProperty(this, "isFirstChunk", true);
+		_defineProperty(this, "previousIncompleteLine", "");
+		_defineProperty(this, "currentEvent", void 0);
+		_defineProperty(this, "lastEventId", void 0);
+		_defineProperty(this, "onEvent", void 0);
+		_defineProperty(this, "onRetry", void 0);
+		_defineProperty(this, "onComment", void 0);
+		this.currentEvent = { data: "" };
+		this.onEvent = (_options$onEvent = options.onEvent) !== null && _options$onEvent !== void 0 ? _options$onEvent : (() => {});
+		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);
+	}
+	finish() {
+		if (this.previousIncompleteLine !== "") this.parseAndProcessLine(this.previousIncompleteLine);
+	}
+	parseAndProcessLine(line) {
+		if (line.startsWith(":")) {
+			var _this$onComment;
+			(_this$onComment = this.onComment) === null || _this$onComment === void 0 || _this$onComment.call(this, this.getValueFromLine(0, line));
+			return;
+		}
+		if (line === "") {
+			this.publishEvent();
+			return;
+		}
+		const content = this.parseContentLine(line);
+		this.processContent(content);
+	}
+	publishEvent() {
+		const data = this.currentEvent.data.endsWith("\n") ? this.currentEvent.data.slice(0, -1) : this.currentEvent.data;
+		if (data) this.onEvent({
+			...this.currentEvent,
+			id: this.lastEventId,
+			data
+		});
+		this.currentEvent = { data: "" };
+	}
+	processContent(content) {
+		switch (content.field) {
+			case "event":
+				this.currentEvent.type = content.value;
+				break;
+			case "data":
+				this.currentEvent.data += content.value + "\n";
+				break;
+			case "id":
+				if (!content.value.includes("\0")) this.lastEventId = content.value;
+				break;
+			case "retry":
+				if (/^\d+$/.test(content.value)) {
+					var _this$onRetry;
+					(_this$onRetry = this.onRetry) === null || _this$onRetry === void 0 || _this$onRetry.call(this, Number.parseInt(content.value, 10));
+				}
+				break;
+			default: break;
+		}
+	}
+	parseContentLine(line) {
+		const delimiterIndex = line.indexOf(":");
+		if (delimiterIndex === -1) return {
+			field: line,
+			value: ""
+		};
+		return {
+			field: line.slice(0, delimiterIndex),
+			value: this.getValueFromLine(delimiterIndex, line)
+		};
+	}
+	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;
+	}
+};
+//#endregion
+//#region ../eventsource/src/EventSourceClient.ts
+var EventSourceClient = class {
+	constructor(options) {
+		var _options$method, _options$fetch;
+		_defineProperty(this, "DEFAULT_SHOULD_RECONNECT", () => true);
+		_defineProperty(this, "DEFAULT_CALCULATE_RECONNECT_DELAY", () => this.serverReconnectionTime);
+		_defineProperty(this, "url", void 0);
+		_defineProperty(this, "headers", void 0);
+		_defineProperty(this, "requestOptions", void 0);
+		_defineProperty(this, "lastEventId", void 0);
+		_defineProperty(this, "reconnectAttempt", 0);
+		_defineProperty(this, "abortController", new AbortController());
+		_defineProperty(this, "reconnectTimeout", void 0);
+		_defineProperty(this, "_readyState", ReadyState.CLOSED);
+		_defineProperty(this, "serverReconnectionTime", 2e3);
+		_defineProperty(this, "_fetch", void 0);
+		_defineProperty(this, "_onError", void 0);
+		_defineProperty(this, "_onMessage", void 0);
+		_defineProperty(this, "_onComment", void 0);
+		_defineProperty(this, "_onConnect", void 0);
+		_defineProperty(this, "_onDisconnect", void 0);
+		_defineProperty(this, "_shouldReconnect", void 0);
+		_defineProperty(this, "_calculateReconnectDelay", void 0);
+		this.url = options.url.toString();
+		this.lastEventId = options.lastEventId;
+		this.headers = {
+			Accept: "text/event-stream",
+			...options.headers
+		};
+		this.requestOptions = {
+			body: options.body,
+			method: (_options$method = options.method) !== null && _options$method !== void 0 ? _options$method : "GET",
+			mode: options.mode,
+			credentials: options.credentials,
+			redirect: options.redirect,
+			referrer: options.referrer,
+			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");
+	}
+	set onError(value) {
+		this._onError = this.getValidatedFunctionOrNoOp(value, "onError");
+	}
+	set onMessage(value) {
+		this._onMessage = this.getValidatedFunctionOrNoOp(value, "onMessage");
+	}
+	set onComment(value) {
+		this._onComment = this.getValidatedFunctionOrNoOp(value, "onComment");
+	}
+	set onConnect(value) {
+		this._onConnect = this.getValidatedFunctionOrNoOp(value, "onConnect");
+	}
+	set onDisconnect(value) {
+		this._onDisconnect = this.getValidatedFunctionOrNoOp(value, "onDisconnect");
+	}
+	set shouldReconnect(value) {
+		this._shouldReconnect = this.getValidatedFunctionOr(value, this.DEFAULT_SHOULD_RECONNECT, "shouldReconnect");
+	}
+	set calculateReconnectDelay(value) {
+		this._calculateReconnectDelay = this.getValidatedFunctionOr(value, this.DEFAULT_CALCULATE_RECONNECT_DELAY, "shouldReconnect");
+	}
+	get readyState() {
+		return this._readyState;
+	}
+	connect() {
+		if (this._readyState !== ReadyState.CLOSED) return;
+		this.reconnectAttempt = 0;
+		this.initiateConnection();
+	}
+	initiateConnection() {
+		this.abortController = new AbortController();
+		this._readyState = ReadyState.CONNECTING;
+		this._fetch(this.url, {
+			...this.requestOptions,
+			headers: this.buildHeaders(),
+			signal: this.abortController.signal,
+			cache: "no-store"
+		}).then(this.handleFetchResponse.bind(this)).catch((error) => {
+			if (error.name === "AbortError" || this.abortController.signal.aborted) {
+				this.close();
+				return;
+			}
+			this._onError(error);
+			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) {
+			this.disconnected();
+			return;
+		}
+		if (status >= 400) {
+			this.scheduleReconnect({ status });
+			return;
+		}
+		if (!body) throw new MissingResponseBodyError("The server response did not have a body");
+		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;
+				this._onMessage(event);
+			},
+			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();
+		this.scheduleReconnect({
+			status,
+			error: new StreamClosedError("The server response stream was closed")
+		});
+	}
+	scheduleReconnect(state) {
+		if (this.abortController.signal.aborted) return;
+		clearTimeout(this.reconnectTimeout);
+		this.reconnectAttempt += 1;
+		const reconnectionState = {
+			attempt: this.reconnectAttempt,
+			status: state.status,
+			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 {
+			this.disconnected();
+			return;
+		}
+	}
+	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`);
+	}
+};
+//#endregion
+//#region ../eventsource/src/index.ts
+const createEventSourceClient = (options) => {
+	return new EventSourceClient(options);
+};
+//#endregion
+//#region ../js-client-core/src/StreamingTransport.ts
+var StreamingTransport = class {
+	constructor(options) {
+		this.options = options;
+		_defineProperty(this, "logger", void 0);
+		_defineProperty(this, "eventSource", void 0);
+		_defineProperty(this, "eventEmitter", new Emitter());
+		_defineProperty(this, "url", void 0);
+		_defineProperty(this, "timeoutTimer", void 0);
+		this.options = options;
+		this.logger = options.logger;
+		this.url = options.resolveUrl("client/sse/v1", options.baseUrl);
+	}
+	async connect(context, timeout) {
+		if (this.eventSource) this.close();
+		const eventSourcePromise = new Promise((resolve, reject) => {
+			this.eventSource = createEventSourceClient({
+				url: this.url,
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				fetch: this.options.fetch,
+				body: JSON.stringify({
+					givenContext: context,
+					metaContext: this.options.metaContext,
+					clientSdkKey: this.options.clientSdkKey
+				}),
+				onMessage: ({ data }) => {
+					this.dispatchMessage(data);
+				},
+				onConnect: () => {
+					this.logger.debug("[EventSourceTransport] Connected");
+					resolve(this);
+				},
+				shouldReconnect: (state) => {
+					const reconnect = !this.isStatusFatal(state.status);
+					if (!reconnect) reject(this.prepareFatalError(state.status, state.error));
+					return reconnect;
+				},
+				calculateReconnectDelay: (state) => {
+					const delay = this.options.connectionRetryDelay(state.attempt);
+					this.logger.warn(`[EventSourceTransport] Scheduling reconnect in ${delay}ms.`);
+					return delay;
+				},
+				onError: (error) => {
+					this.logger.debug("[EventSourceTransport] Error: ", error);
+				},
+				onDisconnect: () => {
+					this.logger.debug("[EventSourceTransport] Disconnected");
+				}
+			});
+			this.eventSource.connect();
+		});
+		clearTimeout(this.timeoutTimer);
+		this.timeoutTimer = void 0;
+		return Promise.race([eventSourcePromise, new Promise((resolve) => {
+			this.timeoutTimer = setTimeout(() => resolve(this), timeout);
+		})]).finally(() => clearTimeout(this.timeoutTimer));
+	}
+	dispatchMessage(data) {
+		try {
+			const json = JSON.parse(data);
+			this.eventEmitter.emit("configSetReceived", json);
+		} catch (error) {
+			this.logger.error("[EventSourceTransport] Error parsing and dispatching config data update: ", error);
+		}
+	}
+	prepareFatalError(responseStatus, error) {
+		const status = responseStatus !== null && responseStatus !== void 0 ? responseStatus : 0;
+		return new ConfigDirectorConnectionError(`${`Connection failed with status: ${responseStatus !== null && responseStatus !== void 0 ? responseStatus : "unknown"}.`}${error ? ` Error: ${error}` : ""}. This is an unrecoverable error, will not attempt to reconnect.`, status);
+	}
+	isStatusFatal(status) {
+		return !!status && status >= 400 && status < 500;
+	}
+	on(name, handler) {
+		this.eventEmitter.on(name, handler);
+	}
+	off(name, handler) {
+		this.eventEmitter.off(name, handler);
+	}
+	clear() {
+		this.eventEmitter.clear();
+	}
+	close() {
+		var _this$eventSource;
+		(_this$eventSource = this.eventSource) === null || _this$eventSource === void 0 || _this$eventSource.close();
+		clearTimeout(this.timeoutTimer);
+	}
+	dispose() {
+		this.close();
+		this.clear();
+	}
+};
+//#endregion
+//#region ../shared/src/value-parser.ts
+const getRequestedType = (defaultValue) => {
+	const baseType = typeof defaultValue;
+	if (baseType === "object") try {
+		var _constructor$name, _constructor;
+		return (_constructor$name = (_constructor = defaultValue.constructor) === null || _constructor === void 0 ? void 0 : _constructor.name) !== null && _constructor$name !== void 0 ? _constructor$name : baseType;
+	} catch {
+		return baseType;
+	}
+	else if (baseType === "function") try {
+		const functionName = defaultValue.name;
+		return functionName ? `function: ${functionName}` : baseType;
+	} catch {
+		return baseType;
+	}
+	return baseType;
+};
+const isNumericNativeType = (requestedType) => {
+	return requestedType === "number" || requestedType === "bigint";
+};
+const parseConfigValue = (configState, defaultValue) => {
+	const value = configState.value;
+	const requestedType = getRequestedType(defaultValue);
+	if (!value) return {
+		parsedValue: defaultValue,
+		requestedType,
+		usedDefault: true,
+		reason: "value-missing"
+	};
+	if (typeof defaultValue === "string") return {
+		parsedValue: value,
+		requestedType,
+		usedDefault: false,
+		reason: "found-match"
+	};
+	if (typeof defaultValue === "boolean" && configState.type === "boolean") {
+		const boolValue = parseConfigBoolean(value);
+		const hasBoolean = typeof boolValue === "boolean";
+		return {
+			parsedValue: hasBoolean ? boolValue : defaultValue,
+			requestedType,
+			usedDefault: !hasBoolean,
+			reason: hasBoolean ? "found-match" : "invalid-boolean"
+		};
+	}
+	if (isNumericNativeType(typeof defaultValue) && configState.type === "integer") {
+		const numValue = parseConfigInteger(value);
+		const hasNumber = typeof numValue === "number";
+		return {
+			parsedValue: hasNumber ? numValue : defaultValue,
+			requestedType,
+			usedDefault: !hasNumber,
+			reason: hasNumber ? "found-match" : "invalid-number"
+		};
+	}
+	if (isNumericNativeType(typeof defaultValue) && (configState.type === "float" || configState.type === "enum")) {
+		const numValue = parseConfigFloat(value);
+		const hasNumber = typeof numValue === "number";
+		return {
+			parsedValue: hasNumber ? numValue : defaultValue,
+			requestedType,
+			usedDefault: !hasNumber,
+			reason: hasNumber ? "found-match" : "invalid-number"
+		};
+	}
+	return {
+		parsedValue: value,
+		requestedType,
+		usedDefault: false,
+		reason: "found-match"
+	};
+};
+const parseConfigBoolean = (value) => {
+	if (!value) return;
+	const lowerValue = value.toLowerCase();
+	if (lowerValue != "true" && lowerValue != "false") return;
+	return lowerValue === "true";
+};
+const parseConfigInteger = (value) => {
+	if (!value) return;
+	const num = Number.parseInt(value);
+	if (isNaN(num) || !isFinite(num)) return;
+	return num;
+};
+const parseConfigFloat = (value) => {
+	if (!value) return;
+	const num = Number.parseFloat(value);
+	if (isNaN(num) || !isFinite(num)) return;
+	return num;
+};
+//#endregion
+//#region ../shared/src/logger.ts
+const LEVELS = {
+	off: -1,
+	error: 0,
+	warn: 1,
+	info: 2,
+	debug: 3
+};
+const buildDateFormatter = () => {
+	const baseOptions = {
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		timeZoneName: "short"
+	};
+	try {
+		return new Intl.DateTimeFormat(void 0, {
+			...baseOptions,
+			fractionalSecondDigits: 3
+		});
+	} catch {
+		return new Intl.DateTimeFormat(void 0, baseOptions);
+	}
+};
+var DefaultConsoleLogger = class {
+	constructor(level, decorator) {
+		this.level = level;
+		this.decorator = decorator;
+		_defineProperty(this, "dateFormatter", void 0);
+		this.level = level;
+		this.decorator = decorator;
+		this.dateFormatter = buildDateFormatter();
+	}
+	debug(message, ...args) {
+		this.log(console.debug, "debug", message, ...args);
+	}
+	info(message, ...args) {
+		this.log(console.info, "info", message, ...args);
+	}
+	warn(message, ...args) {
+		this.log(console.warn, "warn", message, ...args);
+	}
+	error(message, ...args) {
+		this.log(console.error, "error", message, ...args);
+	}
+	log(loggerFunction, level, message, ...args) {
+		if (LEVELS[this.level] >= LEVELS[level]) {
+			var _this$decorator;
+			loggerFunction(`[${this.dateFormatter.format(/* @__PURE__ */ new Date())}] ${(_this$decorator = this.decorator) === null || _this$decorator === void 0 ? void 0 : _this$decorator.decorateMessage(message)}`, ...args);
+		}
+	}
+};
+//#endregion
+//#region ../js-client-core/src/logger.ts
+var LogMessageDecorator = class {
+	decorateMessage(message) {
+		return `[ConfigDirector:js-client-sdk] ${message}`;
+	}
+};
+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/fetchWithTimeout.ts
+const fetchWithTimeout = async (timeout, resource, options, logger) => {
+	const abortController = new AbortController();
+	const abortTimeoutId = setTimeout(() => {
+		logger.debug("[fetchWithTimeout] Reached timeout, aborting request");
+		abortController.abort();
+	}, timeout);
+	try {
+		const response = await fetch(typeof resource === "string" || resource instanceof Request ? resource : resource.toString(), {
+			...options,
+			signal: abortController.signal
+		});
+		clearTimeout(abortTimeoutId);
+		return response;
+	} catch (error) {
+		logger.warn("[fetchWithTimeout] Fetch error: ", error);
+		clearTimeout(abortTimeoutId);
+		throw error;
+	}
+};
+//#endregion
+//#region ../js-client-core/src/PullTransport.ts
+var PullTransport = class {
+	constructor(options) {
+		this.options = options;
+		_defineProperty(this, "logger", void 0);
+		_defineProperty(this, "eventEmitter", new Emitter());
+		_defineProperty(this, "url", void 0);
+		_defineProperty(this, "fatalError", false);
+		this.options = options;
+		this.logger = options.logger;
+		this.url = options.resolveUrl("client/pull/v1", options.baseUrl);
+	}
+	async connect(context, timeout) {
+		if (this.fatalError) {
+			this.logger.warn("[PullTransport] There was a prior unrecoverable error. Ignoring attempt to reconnect.");
+			return this;
+		}
+		try {
+			const response = await fetchWithTimeout(timeout, this.url, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					givenContext: context,
+					metaContext: this.options.metaContext,
+					clientSdkKey: this.options.clientSdkKey
+				})
+			}, 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;
+		} 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}.`);
+		}
+	}
+	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);
+	}
+	off(name, handler) {
+		this.eventEmitter.off(name, handler);
+	}
+	clear() {
+		this.eventEmitter.clear();
+	}
+	close() {}
+	dispose() {
+		this.close();
+		this.clear();
+	}
+};
+//#endregion
+//#region ../shared/src/url.ts
+const defaultUrlFactory = (input, base) => new URL(input, base === null || base === void 0 ? void 0 : base.toString());
+//#endregion
+//#region ../shared/src/constants.ts
+const CLIENT_BASE_URL = "https://client-sdk-api.configdirector.com";
+//#endregion
+//#region ../js-client-core/src/DefaultConfigDirectorClient.ts
+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;
+		_defineProperty(this, "logger", void 0);
+		_defineProperty(this, "telemetryClient", void 0);
+		_defineProperty(this, "configSet", void 0);
+		_defineProperty(this, "handlersMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "transport", void 0);
+		_defineProperty(this, "eventEmitter", new Emitter());
+		_defineProperty(this, "timeout", void 0);
+		_defineProperty(this, "timeoutTimer", void 0);
+		_defineProperty(this, "ready", false);
+		_defineProperty(this, "readyPromise", void 0);
+		_defineProperty(this, "readyResolve", void 0);
+		_defineProperty(this, "currentContext", void 0);
+		_defineProperty(this, "streaming", 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.telemetryClient = telemetryClient;
+		this.transport = new transportConstructor({
+			clientSdkKey,
+			baseUrl,
+			resolveUrl: urlFactory,
+			metaContext: {
+				...clientOptions === null || clientOptions === void 0 ? void 0 : clientOptions.metadata,
+				sdkName: sdkOptions.sdkName,
+				sdkVersion: sdkOptions.sdkVersion,
+				userAgent: (_navigator = navigator) === null || _navigator === void 0 ? void 0 : _navigator.userAgent
+			},
+			logger: this.logger,
+			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;
+			})
+		});
+		this.transport.on("configSetReceived", (configSet) => {
+			var _this$readyResolve;
+			(_this$readyResolve = this.readyResolve) === null || _this$readyResolve === void 0 || _this$readyResolve.call(this);
+			const configKeys = Object.keys(configSet.configs);
+			if (!this.configSet || configSet.kind == "full") {
+				this.configSet = configSet;
+				this.eventEmitter.emit("configsUpdated", { keys: configKeys });
+				this.updateWatchers(configSet.configs);
+			} else {
+				this.configSet.configs = {
+					...this.configSet.configs,
+					...configSet.configs
+				};
+				this.eventEmitter.emit("configsUpdated", { keys: configKeys });
+				this.updateWatchers(configSet.configs);
+			}
+			this.logger.debug("[ConfigDirectorClient] ConfigSet updated from server:", { keys: configKeys });
+		});
+	}
+	async initialize(context) {
+		await this.connectToTransport(context, "initialization");
+	}
+	async updateContext(context) {
+		await this.connectToTransport(context, "context update");
+	}
+	async connectToTransport(context, caller) {
+		try {
+			this.ready = false;
+			this.readyPromise = new Promise((resolve) => {
+				this.readyResolve = resolve;
+			}).then(() => {
+				this.ready = true;
+				this.eventEmitter.emit("clientReady", { action: caller });
+				this.logger.debug("[ConfigDirectorClient] Received initial payload from the server, client is ready");
+			});
+			const startTime = (/* @__PURE__ */ new Date()).getTime();
+			await this.transport.connect(context !== null && context !== void 0 ? context : {}, this.timeout);
+			this.currentContext = context;
+			this.telemetryClient.updateContext(context);
+			const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - startTime;
+			const remainingTimeout = this.timeout - elapsedTime;
+			clearTimeout(this.timeoutTimer);
+			this.timeoutTimer = void 0;
+			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}`);
+			}
+		} catch (error) {
+			this.logger.error(`[ConfigDirectorClient] An error occurred during ${caller}: `, error);
+		}
+	}
+	updateWatchers(configsMap) {
+		Object.values(configsMap).forEach((v) => this.updateWatchersForConfig(v));
+	}
+	updateWatchersForConfig(configState) {
+		var _this$handlersMap$get;
+		(_this$handlersMap$get = this.handlersMap.get(configState.key)) === null || _this$handlersMap$get === void 0 || _this$handlersMap$get.forEach((h) => {
+			const value = this.getValueFromConfigState(configState.key, configState, h.defaultValue);
+			h.handler(value);
+		});
+	}
+	watch(configKey, defaultValue, callback) {
+		this.validateDefaultValue(defaultValue);
+		const handlers = this.handlersMap.get(configKey);
+		const handlerWithOptions = {
+			handler: callback,
+			defaultValue,
+			requestedType: typeof defaultValue
+		};
+		if (handlers) handlers.push(handlerWithOptions);
+		else this.handlersMap.set(configKey, [handlerWithOptions]);
+		return () => this.unwatch(configKey, callback);
+	}
+	unwatch(configKey, callback) {
+		const handlers = this.handlersMap.get(configKey);
+		if (!handlers) return;
+		if (callback) {
+			const index = handlers.findIndex((h) => h.handler == callback);
+			if (index >= 0) handlers === null || handlers === void 0 || handlers.splice(index, 1);
+		} else handlers.splice(0);
+	}
+	getValue(configKey, defaultValue) {
+		var _this$configSet;
+		this.validateDefaultValue(defaultValue);
+		const configState = (_this$configSet = this.configSet) === null || _this$configSet === void 0 ? void 0 : _this$configSet.configs[configKey];
+		return this.getValueFromConfigState(configKey, configState, defaultValue);
+	}
+	getValueFromConfigState(configKey, configState, defaultValue) {
+		var _this$currentContext2;
+		if (!configState) {
+			var _this$currentContext;
+			this.logger.debug(`[ConfigDirectorClient] No config state found for '${configKey}', returning default value '${defaultValue}'`);
+			this.telemetryClient.evaluatedConfig({
+				contextId: (_this$currentContext = this.currentContext) === null || _this$currentContext === void 0 ? void 0 : _this$currentContext.id,
+				key: configKey,
+				defaultValue,
+				requestedType: getRequestedType(defaultValue),
+				evaluatedValue: defaultValue,
+				usedDefault: true,
+				evaluationReason: "config-state-missing"
+			});
+			return defaultValue;
+		}
+		const parseResult = parseConfigValue(configState, defaultValue);
+		this.telemetryClient.evaluatedConfig({
+			contextId: (_this$currentContext2 = this.currentContext) === null || _this$currentContext2 === void 0 ? void 0 : _this$currentContext2.id,
+			key: configKey,
+			defaultValue,
+			requestedType: parseResult.requestedType,
+			evaluatedValue: parseResult.parsedValue,
+			usedDefault: parseResult.usedDefault,
+			evaluationReason: parseResult.reason
+		});
+		this.logger.debug(`[ConfigDirectorClient] Evaluated '${configKey}' to '${parseResult.parsedValue}'`);
+		return parseResult.parsedValue;
+	}
+	parseUrl(url, urlFactory) {
+		if (!url) return;
+		try {
+			return urlFactory(url);
+		} catch (error) {
+			throw new ConfigDirectorValidationError(`Invalid base URL '${url}'. Parsing failed: ${error}`);
+		}
+	}
+	validateDefaultValue(defaultValue) {
+		if (defaultValue === void 0 || defaultValue === null) throw new ConfigDirectorValidationError("Invalid default value. The default value for a config must be defined and non-null.");
+		if (typeof defaultValue === "function") throw new ConfigDirectorValidationError("Invalid default value. The default value for a config cannot be a function.");
+	}
+	get isReady() {
+		return this.ready;
+	}
+	on(eventName, handler) {
+		this.eventEmitter.on(eventName, handler);
+	}
+	off(eventName, handler) {
+		this.eventEmitter.off(eventName, handler);
+	}
+	clear() {
+		this.logger.debug("[ConfigDirectorClient] clear() has been called, removing all observers");
+		this.eventEmitter.clear();
+		this.handlersMap.clear();
+	}
+	unwatchAll() {
+		this.handlersMap.clear();
+	}
+	pauseNetwork() {
+		this.logger.debug("[ConfigDirectorClient] pauseNetwork() called, pausing transport connection");
+		clearTimeout(this.timeoutTimer);
+		this.timeoutTimer = void 0;
+		this.transport.close();
+		this.ready = false;
+	}
+	async resumeNetwork() {
+		await this.connectToTransport(this.currentContext, "network resume");
+	}
+	async close() {
+		var _this$readyResolve2;
+		this.logger.debug("[ConfigDirectorClient] close() has been called, closing connection to server");
+		clearTimeout(this.timeoutTimer);
+		(_this$readyResolve2 = this.readyResolve) === null || _this$readyResolve2 === void 0 || _this$readyResolve2.call(this);
+		this.telemetryClient.close();
+		this.transport.close();
+		this.ready = false;
+	}
+	dispose() {
+		this.clear();
+		this.close();
+	}
+};
+//#endregion
+//#region ../shared/src/telemetry/utils.ts
+const CONFIG_VALUE_MAX_LENGTH = 500;
+const sanitizeValue = (value, type) => {
+	if (type === "json") try {
+		return djb2Hash(JSON.stringify(value));
+	} catch {
+		return value.toString().slice(0, CONFIG_VALUE_MAX_LENGTH);
+	}
+	return value.toString().slice(0, CONFIG_VALUE_MAX_LENGTH);
+};
+const djb2Hash = (data) => {
+	return djb2(new TextEncoder().encode(data)).toString(16).padStart(8, "0");
+};
+const djb2 = (bytes) => {
+	let hash = 5381;
+	for (let i = 0; i < bytes.length; i++) {
+		var _bytes$i;
+		hash = (hash << 5) + hash + ((_bytes$i = bytes[i]) !== null && _bytes$i !== void 0 ? _bytes$i : 0);
+		hash = hash >>> 0;
+	}
+	return hash;
+};
+const isEventListEmpty = (eventList) => {
+	const keys = Object.keys(eventList);
+	if (keys.length == 0) return true;
+	for (const key of keys) {
+		var _eventList$key$length, _eventList$key;
+		if (((_eventList$key$length = (_eventList$key = eventList[key]) === null || _eventList$key === void 0 ? void 0 : _eventList$key.length) !== null && _eventList$key$length !== void 0 ? _eventList$key$length : 0) > 0) return false;
+	}
+	return true;
+};
+const isDroppedEventsEmpty = (droppedEvents) => {
+	if (!droppedEvents) return true;
+	const keys = Object.keys(droppedEvents);
+	if (keys.length == 0) return true;
+	for (const key of keys) {
+		var _droppedEvents$key;
+		if (((_droppedEvents$key = droppedEvents[key]) !== null && _droppedEvents$key !== void 0 ? _droppedEvents$key : 0) > 0) return false;
+	}
+	return true;
+};
+//#endregion
+//#region ../js-client-core/src/telemetry/ClientEventReporter.ts
+var ClientEventReporter = class {
+	constructor(options) {
+		_defineProperty(this, "sdkKey", void 0);
+		_defineProperty(this, "logger", void 0);
+		_defineProperty(this, "url", void 0);
+		_defineProperty(this, "executeRequests", true);
+		this.sdkKey = options.sdkKey;
+		this.logger = options.logger;
+		this.url = options.urlFactory("client/telemetry/v1", options.baseUrl);
+	}
+	async report({ context, discreteEvents, aggregatedEvents, droppedEvents }) {
+		if (!this.executeRequests) return {
+			success: false,
+			fatalError: true
+		};
+		const eventReport = {
+			clientSdkKey: this.sdkKey,
+			context,
+			discreteEvents,
+			aggregatedEvents,
+			droppedEvents
+		};
+		if (this.isReportEmpty(eventReport)) return {
+			success: true,
+			fatalError: false
+		};
+		const response = await this.sendReport(eventReport);
+		if (response.fatalError) this.executeRequests = false;
+		return response;
+	}
+	isReportEmpty(eventReport) {
+		return isEventListEmpty(eventReport.discreteEvents) && isEventListEmpty(eventReport.aggregatedEvents) && isDroppedEventsEmpty(eventReport.droppedEvents);
+	}
+	async sendReport(eventReport) {
+		try {
+			const response = await fetchWithTimeout(5e3, this.url, {
+				method: "POST",
+				body: JSON.stringify(eventReport),
+				keepalive: true
+			}, this.logger);
+			const isFatalError = this.isStatusFatal(response.status);
+			if (isFatalError) this.logger.warn(`[EventReporter] Received a fatal status response (${response.status}) from the telemetry endpoint. No more telemetry data will be sent.`);
+			return {
+				success: response.ok,
+				fatalError: isFatalError
+			};
+		} catch (error) {
+			const isFatal = isFetchErrorFatal(error);
+			this.logger.warn(`[EventReporter] Error attempting to send telemetry data: ${error}`, { error });
+			return {
+				success: false,
+				fatalError: isFatal
+			};
+		}
+	}
+	isStatusFatal(status) {
+		return !!status && status >= 400 && status < 500;
+	}
+};
+//#endregion
+//#region ../shared/src/telemetry/EventAggregator.ts
+var EventAggregator = class {
+	aggregate(snapshot) {
+		if (snapshot.events.length == 0) return [];
+		const map = /* @__PURE__ */ new Map();
+		for (const event of snapshot.events) {
+			var _map$get;
+			const serializedEvent = JSON.stringify(event);
+			const count = ((_map$get = map.get(serializedEvent)) === null || _map$get === void 0 ? void 0 : _map$get.count) || 0;
+			map.set(serializedEvent, {
+				event,
+				count: count + 1
+			});
+		}
+		return Array.from(map).map(([, v]) => {
+			return {
+				startTime: snapshot.startTime,
+				endTime: snapshot.endTime,
+				count: v.count,
+				event: v.event
+			};
+		});
+	}
+};
+//#endregion
+//#region ../shared/src/telemetry/EventQueue.ts
+var EventQueue = class {
+	constructor(limit) {
+		_defineProperty(this, "limit", void 0);
+		_defineProperty(this, "startTime", void 0);
+		_defineProperty(this, "_events", []);
+		_defineProperty(this, "_droppedEventCount", 0);
+		this.limit = limit !== null && limit !== void 0 ? limit : 1e3;
+	}
+	get events() {
+		return this._events;
+	}
+	get reachedLimit() {
+		return this._events.length >= this.limit;
+	}
+	get droppedEventCount() {
+		return this._droppedEventCount;
+	}
+	push(...newEvents) {
+		if (!this.startTime) this.startTime = /* @__PURE__ */ new Date();
+		const newEventsCountToDrop = Math.max(0, newEvents.length - this.limit);
+		const eventsToPush = newEvents.slice(newEventsCountToDrop, newEvents.length);
+		this._droppedEventCount += newEventsCountToDrop;
+		if (this._events.length + eventsToPush.length > this.limit) {
+			const eventCountToDrop = this._events.length + eventsToPush.length - this.limit;
+			this._events.splice(0, eventCountToDrop);
+			this._droppedEventCount += eventCountToDrop;
+		}
+		return this._events.push(...eventsToPush);
+	}
+	takeSnapshot() {
+		var _this$startTime;
+		const endTime = /* @__PURE__ */ new Date();
+		const startTime = (_this$startTime = this.startTime) !== null && _this$startTime !== void 0 ? _this$startTime : endTime;
+		const eventsSnapshot = this._events.splice(0);
+		const droppedCount = this._droppedEventCount;
+		this.startTime = void 0;
+		this._droppedEventCount = 0;
+		return {
+			startTime,
+			endTime,
+			events: eventsSnapshot,
+			droppedCount
+		};
+	}
+	clear() {
+		this._events = [];
+		this.startTime = void 0;
+		this._droppedEventCount = 0;
+	}
+};
+//#endregion
+//#region ../shared/src/telemetry/TelemetryEventCollector.ts
+var TelemetryEventCollector = class {
+	constructor(options) {
+		var _options$evaluationQu, _options$flushInterva, _options$initialFlush;
+		_defineProperty(this, "logger", void 0);
+		_defineProperty(this, "evaluationEventQueue", void 0);
+		_defineProperty(this, "aggregator", new EventAggregator());
+		_defineProperty(this, "flushIntervalDelay", void 0);
+		_defineProperty(this, "flushTimeout", void 0);
+		_defineProperty(this, "collectEvents", true);
+		this.logger = options.logger;
+		this.evaluationEventQueue = new EventQueue((_options$evaluationQu = options.evaluationQueueLimit) !== null && _options$evaluationQu !== void 0 ? _options$evaluationQu : 1e3);
+		this.flushIntervalDelay = (_options$flushInterva = options.flushIntervalDelay) !== null && _options$flushInterva !== void 0 ? _options$flushInterva : 3e4;
+		const initialDelay = (_options$initialFlush = options.initialFlushIntervalDelay) !== null && _options$initialFlush !== void 0 ? _options$initialFlush : 5e3;
+		this.flushTimeout = setTimeout(() => this.flushAndScheduleNext(), initialDelay);
+	}
+	sanitizeValue(value, type) {
+		return sanitizeValue(value, type);
+	}
+	async flushAndScheduleNext() {
+		if ((await this.flush()).fatalError) {
+			this.collectEvents = false;
+			this.close();
+			this.logger.warn("[TelemetryEventCollector] Received a fatal error from telemetry collection. No longer collecting events.");
+		} else this.flushTimeout = setTimeout(() => this.flushAndScheduleNext(), this.flushIntervalDelay);
+	}
+	async flush() {
+		var _this$reporter;
+		if (!this.reporter) return {
+			success: false,
+			fatalError: false
+		};
+		const evaluationSnapshot = this.evaluationEventQueue.takeSnapshot();
+		return await ((_this$reporter = this.reporter) === null || _this$reporter === void 0 ? void 0 : _this$reporter.report({
+			context: this._context,
+			discreteEvents: {},
+			aggregatedEvents: { evaluatedConfig: this.aggregator.aggregate(evaluationSnapshot) },
+			droppedEvents: { evaluatedConfig: evaluationSnapshot.droppedCount }
+		}));
+	}
+	cancelScheduledFlush() {
+		clearTimeout(this.flushTimeout);
+	}
+	async close() {
+		this.collectEvents = false;
+		clearTimeout(this.flushTimeout);
+		await this.flush();
+		this.evaluationEventQueue.clear();
+	}
+	dispose() {
+		this.close();
+	}
+};
+//#endregion
+//#region ../js-client-core/src/telemetry/ClientTelemetryEventCollector.ts
+var ClientTelemetryEventCollector = class extends TelemetryEventCollector {
+	constructor(options) {
+		super(options);
+		_defineProperty(this, "reporter", void 0);
+		_defineProperty(this, "_context", void 0);
+		this.reporter = new ClientEventReporter(options);
+	}
+	async updateContext(value) {
+		this.cancelScheduledFlush();
+		await this.flush();
+		this._context = value;
+		await this.flushAndScheduleNext();
+	}
+	evaluatedConfig(event) {
+		if (!this.collectEvents) return;
+		this.evaluationEventQueue.push(event);
+	}
+	async forceFlush() {
+		this.cancelScheduledFlush();
+		await this.flushAndScheduleNext();
+	}
+};
+//#endregion
+//#region src/logger.ts
+var MessageDecorator = class {
+	decorateMessage(message) {
+		return `[ConfigDirector:react-native-sdk] ${message}`;
+	}
+};
+const createConsoleLogger = (level) => createDefaultLogger(level, new MessageDecorator());
+//#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.
+*/
+const encodeUtf8 = (str) => {
+	if (typeof globalThis["TextEncoder"] === "function") return new TextEncoder().encode(str);
+	const uri = encodeURIComponent(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++;
+	}
+	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.
+*/
+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"));
+	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;
+		} });
+		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(": "));
+				});
+				resolve({
+					status: xhr.status,
+					headers,
+					body: stream
+				});
+			}
+		};
+		xhr.onprogress = () => {
+			const newText = xhr.responseText.slice(lastLength);
+			lastLength = xhr.responseText.length;
+			if (newText) controller.enqueue(encodeUtf8(newText));
+		};
+		xhr.onload = () => {
+			const remaining = xhr.responseText.slice(lastLength);
+			if (remaining) controller.enqueue(encodeUtf8(remaining));
+			controller.close();
+		};
+		xhr.onerror = () => {
+			const error = /* @__PURE__ */ new TypeError("Network request failed");
+			if (!resolved) reject(error);
+			else controller.error(error);
+			xhr.abort();
+		};
+		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();
+			} catch {}
+		});
+		xhr.send((_ref = init.body) !== null && _ref !== void 0 ? _ref : null);
+	});
+};
+//#endregion
+//#region src/ReactNativeTelemetryClient.ts
+var ReactNativeTelemetryClient = class {
+	constructor(sdkKey, baseUrl, logger, urlFactory) {
+		_defineProperty(this, "collector", void 0);
+		this.collector = new ClientTelemetryEventCollector({
+			sdkKey,
+			logger,
+			baseUrl,
+			urlFactory
+		});
+	}
+	async updateContext(value) {
+		return await this.collector.updateContext(value);
+	}
+	evaluatedConfig(event) {
+		this.collector.evaluatedConfig(this.sanitizeEvaluatedConfigEvent(event));
+	}
+	async close() {
+		await this.collector.close();
+	}
+	sanitizeEvaluatedConfigEvent(event) {
+		return {
+			...event,
+			defaultValue: sanitizeValue(event.defaultValue, event.type),
+			evaluatedValue: sanitizeValue(event.evaluatedValue, event.type)
+		};
+	}
+};
+//#endregion
+//#region src/url.ts
+var MinimalUrl = class {
+	constructor(input, base) {
+		_defineProperty(this, "href", void 0);
+		if (base) {
+			const b = base.toString();
+			this.href = (b.endsWith("/") ? b : b + "/") + input;
+		} else this.href = input;
+	}
+	toString() {
+		return this.href;
+	}
+};
+const urlFactory = (input, base) => new MinimalUrl(input, base);
+//#endregion
+//#region src/client.ts
+const createClient = (clientSdkKey, clientOptions) => {
+	var _clientOptions$logger, _clientOptions$connec;
+	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"
+	}, {
+		...clientOptions,
+		logger
+	}, {
+		fetch: reactNativeStreamingFetch,
+		urlFactory
+	});
+};
+//#endregion
+//#region src/context.tsx
+const createReactContext = () => React.createContext({ status: "loading" });
+const reactContext = createReactContext();
+//#endregion
+//#region src/provider.tsx
+var ConfigDirectorProvider = class extends Component {
+	constructor(props) {
+		var _props$logger;
+		super(props);
+		_defineProperty(this, "appStateSubscription", null);
+		_defineProperty(this, "netInfoUnsubscribe", null);
+		_defineProperty(this, "wasOffline", false);
+		_defineProperty(this, "handleAppStateChange", async (nextState) => {
+			if (nextState === "active") await this.reconnect();
+			else if (nextState === "background") {
+				var _this$state$client;
+				(_this$state$client = this.state.client) === null || _this$state$client === void 0 || _this$state$client.pauseNetwork();
+			}
+		});
+		_defineProperty(this, "handleConnectivityChange", ({ isConnected }) => {
+			if (!isConnected) this.wasOffline = true;
+			else if (this.wasOffline && AppState.currentState !== "background") {
+				this.wasOffline = false;
+				this.reconnect();
+			}
+		});
+		_defineProperty(this, "reconnect", async () => {
+			var _this$state$client2;
+			await ((_this$state$client2 = this.state.client) === null || _this$state$client2 === void 0 ? void 0 : _this$state$client2.resumeNetwork());
+		});
+		this.state = {
+			client: createClient(props.sdkKey, {
+				connection: {
+					url: props.url,
+					timeout: props.timeout
+				},
+				metadata: {
+					appName: props.appName,
+					appVersion: props.appVersion
+				},
+				logger: (_props$logger = props.logger) !== null && _props$logger !== void 0 ? _props$logger : createConsoleLogger("warn")
+			}),
+			status: "loading"
+		};
+	}
+	async componentDidMount() {
+		var _this$state$client3, _this$state$client4, _this$state$client5, _this$state$client6;
+		(_this$state$client3 = this.state.client) === null || _this$state$client3 === void 0 || _this$state$client3.on("configsUpdated", () => {
+			this.setState({ updatedAt: /* @__PURE__ */ new Date() });
+		});
+		(_this$state$client4 = this.state.client) === null || _this$state$client4 === void 0 || _this$state$client4.on("clientReady", () => {
+			this.setState({ status: "ready" });
+		});
+		await ((_this$state$client5 = this.state.client) === null || _this$state$client5 === void 0 ? void 0 : _this$state$client5.initialize(this.props.context));
+		if (!((_this$state$client6 = this.state.client) === null || _this$state$client6 === void 0 ? void 0 : _this$state$client6.isReady)) this.setState({ status: "default" });
+		this.appStateSubscription = AppState.addEventListener("change", this.handleAppStateChange);
+		if (this.props.netInfoSubscribe) this.netInfoUnsubscribe = this.props.netInfoSubscribe(this.handleConnectivityChange);
+	}
+	async componentDidUpdate(prevProps) {
+		if (prevProps.context !== this.props.context) {
+			var _this$state$client7, _this$props$context, _this$state$client8;
+			this.setState({ status: "loading" });
+			await ((_this$state$client7 = this.state.client) === null || _this$state$client7 === void 0 ? void 0 : _this$state$client7.updateContext((_this$props$context = this.props.context) !== null && _this$props$context !== void 0 ? _this$props$context : {}));
+			if (!((_this$state$client8 = this.state.client) === null || _this$state$client8 === void 0 ? void 0 : _this$state$client8.isReady)) this.setState({ status: "default" });
+		}
+	}
+	componentWillUnmount() {
+		var _this$appStateSubscri, _this$netInfoUnsubscr, _this$state$client9;
+		(_this$appStateSubscri = this.appStateSubscription) === null || _this$appStateSubscri === void 0 || _this$appStateSubscri.remove();
+		(_this$netInfoUnsubscr = this.netInfoUnsubscribe) === null || _this$netInfoUnsubscr === void 0 || _this$netInfoUnsubscr.call(this);
+		(_this$state$client9 = this.state.client) === null || _this$state$client9 === void 0 || _this$state$client9.dispose();
+	}
+	render() {
+		return /* @__PURE__ */ jsx(reactContext.Provider, {
+			value: this.state,
+			children: this.props.children
+		});
+	}
+};
+//#endregion
+//#region src/errors.ts
+var ConfigDirectorReactContextError = class ConfigDirectorReactContextError extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "name", "ConfigDirectorReactContextError");
+		Object.setPrototypeOf(this, ConfigDirectorReactContextError.prototype);
+	}
+};
+//#endregion
+//#region src/hooks.tsx
+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);
+	if (!(configDirectorReactContext === null || configDirectorReactContext === void 0 ? void 0 : configDirectorReactContext.client)) throw noContextError();
+	return {
+		value: configDirectorReactContext.client.getValue(key, defaultValue),
+		readyStatus: configDirectorReactContext.status,
+		loading: configDirectorReactContext.status === "loading"
+	};
+};
+const useConfigDirectorContext = () => {
+	const configDirectorReactContext = useContext(reactContext);
+	if (!(configDirectorReactContext === null || configDirectorReactContext === void 0 ? void 0 : configDirectorReactContext.client)) throw noContextError();
+	const updateContext = async (context) => {
+		var _configDirectorReactC;
+		await ((_configDirectorReactC = configDirectorReactContext.client) === null || _configDirectorReactC === void 0 ? void 0 : _configDirectorReactC.updateContext(context));
+	};
+	return { updateContext };
+};
+const useConfigDirectorClient = () => {
+	const configDirectorReactContext = useContext(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 };