@configdirector/nuxt-sdk 0.1.0

package/dist/runtime/nitro/plugin.mjs

@@ -0,0 +1,1397 @@
+import EventEmitter, { EventEmitter as EventEmitter$1 } from "node:events";
+import { findByPointer } from "@jsonjoy.com/json-pointer";
+import * as semver from "semver";
+import { rapidhash } from "rapidhash-js";
+import { defineNitroPlugin, useRuntimeConfig } from "nitropack/runtime";
+import { consola } from "consola";
+//#region ../shared/src/errors.ts
+var ConfigDirectorConnectionError = class ConfigDirectorConnectionError extends Error {
+	name = "ConfigDirectorConnectionError";
+	status;
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+		Object.setPrototypeOf(this, ConfigDirectorConnectionError.prototype);
+	}
+};
+var ConfigDirectorValidationError = class ConfigDirectorValidationError extends Error {
+	name = "ConfigDirectorValidationError";
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, ConfigDirectorValidationError.prototype);
+	}
+};
+var ConfigDirectorInitializationError = class ConfigDirectorInitializationError extends Error {
+	name = "ConfigDirectorInitializationError";
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, ConfigDirectorInitializationError.prototype);
+	}
+};
+//#endregion
+//#region ../eventsource/src/errors.ts
+var StreamClosedError = class StreamClosedError extends Error {
+	name = "StreamClosedError";
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, StreamClosedError.prototype);
+	}
+};
+var MissingResponseBodyError = class MissingResponseBodyError extends Error {
+	name = "MissingResponseBodyError";
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, MissingResponseBodyError.prototype);
+	}
+};
+var InvalidOptionError = class InvalidOptionError extends Error {
+	name = "InvalidOptionError";
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, InvalidOptionError.prototype);
+	}
+};
+var ValueOutOfRangeError = class ValueOutOfRangeError extends Error {
+	name = "ValueOutOfRangeError";
+	constructor(message) {
+		super(message);
+		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 {
+	isFirstChunk = true;
+	bufferedInput = "";
+	currentEvent = { data: "" };
+	lastEventId;
+	onEvent;
+	onRetry;
+	onComment;
+	constructor(options) {
+		this.currentEvent = { data: "" };
+		this.onEvent = options.onEvent ?? (() => {});
+		this.onRetry = options.onRetry;
+		this.onComment = options.onComment;
+	}
+	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() {
+		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;
+	}
+	dispatchLine(line) {
+		if (line.startsWith(":")) {
+			this.onComment?.(this.extractValue(line, 1));
+			return;
+		}
+		if (line === "") {
+			this.emitEvent();
+			return;
+		}
+		this.applyField(this.parseField(line));
+	}
+	emitEvent() {
+		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: "" };
+	}
+	applyField(parsed) {
+		switch (parsed.field) {
+			case "event":
+				this.currentEvent.type = parsed.value;
+				break;
+			case "data":
+				this.currentEvent.data += parsed.value + "\n";
+				break;
+			case "id":
+				if (!parsed.value.includes("\0")) this.lastEventId = parsed.value;
+				break;
+			case "retry":
+				if (/^\d+$/.test(parsed.value)) this.onRetry?.(Number.parseInt(parsed.value, 10));
+				break;
+			default: break;
+		}
+	}
+	parseField(line) {
+		const colon = line.indexOf(":");
+		if (colon === -1) return {
+			field: line,
+			value: ""
+		};
+		return {
+			field: line.slice(0, colon),
+			value: this.extractValue(line, colon + 1)
+		};
+	}
+	/** 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
+//#region ../eventsource/src/EventSourceClient.ts
+var EventSourceClient = class {
+	DEFAULT_SHOULD_RECONNECT = () => true;
+	DEFAULT_CALCULATE_RECONNECT_DELAY = () => this.serverReconnectionTime;
+	url;
+	headers;
+	requestOptions;
+	lastEventId;
+	reconnectAttempt = 0;
+	abortController = new AbortController();
+	reconnectTimeout;
+	_readyState = ReadyState.CLOSED;
+	serverReconnectionTime = 2e3;
+	_fetch;
+	_onError;
+	_onMessage;
+	_onComment;
+	_onConnect;
+	_onDisconnect;
+	_shouldReconnect;
+	_calculateReconnectDelay;
+	constructor(options) {
+		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 ?? "GET",
+			mode: options.mode,
+			credentials: options.credentials,
+			redirect: options.redirect,
+			referrer: options.referrer,
+			referrerPolicy: options.referrerPolicy
+		};
+		this._fetch = options.fetch ?? ((url, init) => fetch(url, init));
+		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.resolveCallback(value, () => {}, "onError");
+	}
+	set onMessage(value) {
+		this._onMessage = this.resolveCallback(value, () => {}, "onMessage");
+	}
+	set onComment(value) {
+		this._onComment = this.resolveCallback(value, () => {}, "onComment");
+	}
+	set onConnect(value) {
+		this._onConnect = this.resolveCallback(value, () => {}, "onConnect");
+	}
+	set onDisconnect(value) {
+		this._onDisconnect = this.resolveCallback(value, () => {}, "onDisconnect");
+	}
+	set shouldReconnect(value) {
+		this._shouldReconnect = this.resolveCallback(value, this.DEFAULT_SHOULD_RECONNECT, "shouldReconnect");
+	}
+	set calculateReconnectDelay(value) {
+		this._calculateReconnectDelay = this.resolveCallback(value, this.DEFAULT_CALCULATE_RECONNECT_DELAY, "shouldReconnect");
+	}
+	get readyState() {
+		return this._readyState;
+	}
+	connect() {
+		if (this._readyState !== ReadyState.CLOSED) return;
+		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.buildRequestHeaders(),
+			signal: this.abortController.signal,
+			cache: "no-store"
+		}).then((response) => this.handleFetchResponse(response)).catch((error) => {
+			if (error.name === "AbortError" || this.abortController.signal.aborted) {
+				this.close();
+				return;
+			}
+			this._onError(error);
+			this.scheduleReconnect({ error });
+		});
+	}
+	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 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
+		});
+		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);
+		this.reconnectAttempt += 1;
+		const reconnectionState = {
+			attempt: this.reconnectAttempt,
+			status: state.status,
+			error: state.error,
+			serverReconnectionTime: this.serverReconnectionTime
+		};
+		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);
+	}
+	resolveCallback(provided, fallback, optionName) {
+		if (provided == null) return fallback;
+		if (typeof provided !== "function") throw new InvalidOptionError(`${optionName} must be a function`);
+		return provided;
+	}
+};
+//#endregion
+//#region ../eventsource/src/index.ts
+const createEventSourceClient = (options) => {
+	return new EventSourceClient(options);
+};
+//#endregion
+//#region ../js-server-sdk/src/StreamingTransport.ts
+const MAX_EXPONENTIAL_DELAY = 9;
+var StreamingTransport = class {
+	logger;
+	eventSource;
+	eventEmitter = new EventEmitter$1();
+	url;
+	constructor(options) {
+		this.options = options;
+		this.options = options;
+		this.logger = options.logger;
+		this.url = new URL("server/sse/v1", options.baseUrl);
+	}
+	async connect(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" },
+				body: JSON.stringify({
+					metaContext: this.options.metaContext,
+					serverSdkKey: this.options.serverSdkKey
+				}),
+				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 = Math.pow(2, Math.min(state.attempt, MAX_EXPONENTIAL_DELAY)) * 1e3;
+					this.logger.warn(`[EventSourceTransport] Scheduling reconnect in ${delay}ms.`);
+					return delay;
+				},
+				onDisconnect: () => {
+					this.logger.debug("[EventSourceTransport] Disconnected");
+				}
+			});
+			this.eventSource.connect();
+		});
+		return Promise.race([eventSourcePromise, new Promise((resolve) => {
+			setTimeout(() => resolve(this), timeout);
+		})]);
+	}
+	dispatchMessage(data) {
+		try {
+			const json = JSON.parse(data);
+			this.eventEmitter.emit("configBundleReceived", json);
+		} catch (error) {
+			this.logger.error("[EventSourceTransport] Error parsing and dispatching config data update: ", error);
+		}
+	}
+	prepareFatalError(responseStatus, error) {
+		const status = responseStatus ?? 0;
+		return new ConfigDirectorConnectionError(`${`Connection failed with status: ${responseStatus ?? "unknown"}.`}${error ? ` Error: ${error}.` : ""} This is an unrecoverable error, will not attempt to reconnect.`, status);
+	}
+	isStatusFatal(status) {
+		return !!status && status >= 400 && status < 500;
+	}
+	get isConnected() {
+		return this.eventSource?.readyState == "open";
+	}
+	on(name, handler) {
+		this.eventEmitter.on(name, handler);
+	}
+	off(name, handler) {
+		if (handler) this.eventEmitter.off(name, handler);
+		else this.eventEmitter.removeAllListeners(name);
+	}
+	clear() {
+		this.eventEmitter.removeAllListeners();
+	}
+	close() {
+		this.eventSource?.close();
+	}
+	dispose() {
+		this.close();
+		this.clear();
+	}
+};
+//#endregion
+//#region ../config-evaluator/src/text-comparison.ts
+const compareText = (value, operator, targetValues) => {
+	switch (operator.toLowerCase()) {
+		case "=":
+		case "equals": return value == targetValues[0];
+		case "!=":
+		case "does not equal": return value != targetValues[0];
+		case "is one of": return targetValues.includes(value);
+		case "is not one of": return !targetValues.includes(value);
+		case "starts with any of": return targetValues.findIndex((v) => value?.startsWith(v)) >= 0;
+		case "does not start with any of": return targetValues.findIndex((v) => value?.startsWith(v)) < 0;
+		case "ends with any of": return targetValues.findIndex((v) => value?.endsWith(v)) >= 0;
+		case "does not end with any of": return targetValues.findIndex((v) => value?.endsWith(v)) < 0;
+		case "matches regex": return matchesRegex(targetValues[0], value);
+		case "does not match regex": return !matchesRegex(targetValues[0], value);
+		default: return false;
+	}
+};
+const matchesRegex = (regexString, value) => {
+	try {
+		return new RegExp(regexString).test(value);
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region ../config-evaluator/src/numeric-comparison.ts
+const compareNumeric = (givenValue, operator, targetValues) => {
+	if (typeof givenValue == "boolean") return false;
+	const lowercaseOperator = operator.toLowerCase();
+	if (givenValue == null) return lowercaseOperator == "!=" || lowercaseOperator == "does not equal";
+	const { value, target } = parseValueAndTarget(givenValue, targetValues[0]);
+	switch (lowercaseOperator) {
+		case "=":
+		case "equals": return value == target;
+		case "!=":
+		case "does not equal": return value != target;
+		case "<": return value < target;
+		case "<=": return value <= target;
+		case ">": return value > target;
+		case ">=": return value >= target;
+		default: return false;
+	}
+};
+const parseValueAndTarget = (value, targetValue) => {
+	if (typeof value == "number") return {
+		value,
+		target: parseAsNumber(targetValue)
+	};
+	else if (typeof value == "bigint") return {
+		value,
+		target: BigInt(targetValue)
+	};
+	else return {
+		value: parseAsNumber(value),
+		target: parseAsNumber(targetValue)
+	};
+};
+const parseAsNumber = (value) => {
+	const n = Number.parseFloat(value.toString());
+	if (isNaN(n) || !isFinite(n)) throw new TypeError(`Invalid numeric value: ${value}`);
+	return n;
+};
+//#endregion
+//#region ../config-evaluator/src/date-comparison.ts
+const compareDate = (value, operator, targetValues) => {
+	if (value == null) return false;
+	try {
+		const dateValue = new Date(value);
+		const dateTarget = new Date(targetValues[0]);
+		switch (operator) {
+			case "is after": return dateValue > dateTarget;
+			case "is before": return dateValue < dateTarget;
+			default: return false;
+		}
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region ../config-evaluator/src/semver-comparison.ts
+const compareSemver = (value, operator, targetValues) => {
+	const lowercaseOperator = operator.toLowerCase();
+	if (value == null || value.trim().length == 0) return lowercaseOperator == "is not one of";
+	const semverValue = semver.coerce(value) ?? value;
+	const semverTargets = targetValues.map((v) => semver.coerce(v) ?? v);
+	try {
+		switch (lowercaseOperator) {
+			case "=": return safeEquals(semverValue, semverTargets[0]);
+			case "<": return semver.lt(semverValue, semverTargets[0]);
+			case "<=": return semver.lte(semverValue, semverTargets[0]);
+			case ">": return semver.gt(semverValue, semverTargets[0]);
+			case ">=": return semver.gte(semverValue, semverTargets[0]);
+			case "is one of": return semverTargets.findIndex((v) => safeEquals(semverValue, v)) >= 0;
+			case "is not one of": return semverTargets.findIndex((v) => safeEquals(semverValue, v)) < 0;
+			default: return false;
+		}
+	} catch {
+		return false;
+	}
+};
+const safeEquals = (v1, v2) => {
+	try {
+		return semver.eq(v1, v2);
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region ../config-evaluator/src/array-comparison.ts
+const compareArray = (givenValue, operator, targetValues) => {
+	const lowercaseOperator = operator.toLowerCase();
+	if (!Array.isArray(givenValue)) return lowercaseOperator == "does not contain any of";
+	switch (lowercaseOperator) {
+		case "contains any of": return givenValue.some((v) => targetValues.includes(v));
+		case "does not contain any of": return !givenValue.some((v) => targetValues.includes(v));
+		default: return false;
+	}
+};
+//#endregion
+//#region ../config-evaluator/src/ConditionEvaluator.ts
+var ConditionEvaluator = class {
+	evaluate(condition, context) {
+		if (!this.isConditionValidForComparison(condition)) return false;
+		switch (condition.attribute) {
+			case "identifier": return this.compare(context?.context?.id, condition);
+			case "name": return this.compare(context?.context?.name, condition);
+			case "appName": return this.compare(context?.metadata?.appName, condition);
+			case "appVersion": return this.compare(context?.metadata?.appVersion, condition);
+			case "traits": if (condition.trait) {
+				const value = this.findTraitValue(context?.context?.traits, condition.trait);
+				return this.compare(value, condition);
+			}
+		}
+		return false;
+	}
+	compare(value, condition) {
+		switch (condition.targetType) {
+			case "text": return compareText(value?.toString(), condition.operator, condition.targetValues);
+			case "number": return compareNumeric(value, condition.operator, condition.targetValues);
+			case "datetime": return compareDate(value?.toString(), condition.operator, condition.targetValues);
+			case "semver": return compareSemver(value?.toString(), condition.operator, condition.targetValues);
+			case "array": return compareArray(value, condition.operator, condition.targetValues);
+		}
+		return false;
+	}
+	findTraitValue(traits, path) {
+		try {
+			return findByPointer(path, traits).val;
+		} catch {
+			return;
+		}
+	}
+	isConditionValidForComparison(condition) {
+		return Array.isArray(condition.targetValues) && condition.targetValues.length > 0;
+	}
+};
+//#endregion
+//#region ../config-evaluator/src/percent-hashing.ts
+const SEED = 15426857351n;
+const assignPercentage = (data) => {
+	const value = `${data.contextIdentifier}-${data.configId}`;
+	return Number(rapidhash(value, { seed: SEED }) % 1000n) / 10;
+};
+//#endregion
+//#region ../config-evaluator/src/ConfigEvaluator.ts
+var ConfigEvaluator = class {
+	conditionEvaluator = new ConditionEvaluator();
+	constructor(logger) {
+		this.logger = logger;
+		if (!logger || !logger.warn || !logger.error || !logger.info) throw new TypeError("The provided logger is not a valid 'ConfigDirectorLogger'");
+		this.logger = logger;
+	}
+	evaluate(config, context) {
+		return {
+			id: config.id,
+			key: config.key,
+			type: config.type,
+			value: this.getConfigValue(config, context)
+		};
+	}
+	getConfigValue(config, context) {
+		const rules = [...config.target?.rules ?? []].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
+		for (const rule of rules) {
+			const result = this.evaluateRule(rule, config, context);
+			if (result.success) return result.value;
+		}
+		return config.target?.defaultValue;
+	}
+	evaluateRule(rule, config, context) {
+		try {
+			if (rule.type == "percentage") return this.evaluatePercentageRule(rule, config, context);
+			else if (rule.type == "conditional") return this.evaluateConditionalRule(rule, config, context);
+		} catch (error) {
+			this.logger.warn(`There was an error while evaluating a targeting rule '${rule?.id}' for '${config?.key}'. The rule will be disregarded.`, {
+				error,
+				configKey: config?.key,
+				ruleId: rule?.id
+			});
+		}
+		return { success: false };
+	}
+	evaluatePercentageRule(rule, config, context) {
+		return this.evaluatePercentage(rule.percentages ?? [], config, context);
+	}
+	evaluatePercentage(percentages, config, context) {
+		const assignedPercentage = assignPercentage({
+			configId: config.id,
+			contextIdentifier: context?.context?.id ?? crypto.randomUUID()
+		});
+		let index = 0;
+		let sum = 0;
+		let bucket = void 0;
+		while (!bucket && index < percentages.length) {
+			if (assignedPercentage <= percentages[index].percentage + sum) bucket = percentages[index];
+			sum += percentages[index].percentage;
+			index += 1;
+		}
+		if (bucket?.value != null) return {
+			success: true,
+			value: bucket.value.toString()
+		};
+		return { success: false };
+	}
+	evaluateConditionalRule(rule, config, context) {
+		const conditions = rule.conditions ?? [];
+		let index = 0;
+		let condition = void 0;
+		while (!condition && index < conditions.length) {
+			if (this.conditionEvaluator.evaluate(conditions[index], context)) condition = conditions[index];
+			index += 1;
+		}
+		if (condition && rule.target == "value" && rule.value != null) return {
+			success: true,
+			value: rule.value.toString()
+		};
+		else if (condition && rule.target == "percentage") return this.evaluatePercentage(rule.percentages ?? [], config, context);
+		return { success: false };
+	}
+};
+//#endregion
+//#region ../shared/src/value-parser.ts
+const getRequestedType = (defaultValue) => {
+	const baseType = typeof defaultValue;
+	if (baseType === "object") try {
+		return defaultValue.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 {
+	dateFormatter;
+	constructor(level, decorator) {
+		this.level = level;
+		this.decorator = decorator;
+		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]) loggerFunction(`[${this.dateFormatter.format(/* @__PURE__ */ new Date())}] ${this.decorator?.decorateMessage(message)}`, ...args);
+	}
+};
+//#endregion
+//#region ../js-server-sdk/src/logger.ts
+var LogMessageDecorator = class {
+	decorateMessage(message) {
+		return `[ConfigDirector:js-server-sdk] ${message}`;
+	}
+};
+const createDefaultLogger$1 = (level, messageDecorator) => {
+	return new DefaultConsoleLogger(level ?? "warn", messageDecorator ?? new LogMessageDecorator());
+};
+//#endregion
+//#region ../shared/src/url.ts
+const defaultUrlFactory = (input, base) => new URL(input, base?.toString());
+//#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++) {
+		hash = (hash << 5) + hash + (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) if ((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) if ((droppedEvents[key] ?? 0) > 0) return false;
+	return true;
+};
+//#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-server-sdk/src/telemetry/ServerEventReporter.ts
+var ServerEventReporter = class {
+	sdkKey;
+	logger;
+	url;
+	executeRequests = true;
+	constructor(options) {
+		this.sdkKey = options.sdkKey;
+		this.logger = options.logger;
+		this.url = new URL("server/telemetry/v1", options.baseUrl.toString());
+	}
+	async report({ discreteEvents, aggregatedEvents, droppedEvents }) {
+		if (!this.executeRequests) return {
+			success: false,
+			fatalError: true
+		};
+		const eventReport = {
+			serverSdkKey: this.sdkKey,
+			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)
+			}, 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) {
+			this.logger.warn(`[EventReporter] Error attempting to send telemetry data: ${error}`, { error });
+			return {
+				success: false,
+				fatalError: false
+			};
+		}
+	}
+	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) {
+			const serializedEvent = JSON.stringify(event);
+			const count = map.get(serializedEvent)?.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 {
+	limit;
+	startTime;
+	_events = [];
+	_droppedEventCount = 0;
+	constructor(limit) {
+		this.limit = 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() {
+		const endTime = /* @__PURE__ */ new Date();
+		const startTime = 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 {
+	logger;
+	evaluationEventQueue;
+	aggregator = new EventAggregator();
+	flushIntervalDelay;
+	flushTimeout;
+	collectEvents = true;
+	constructor(options) {
+		this.logger = options.logger;
+		this.evaluationEventQueue = new EventQueue(options.evaluationQueueLimit ?? 1e3);
+		this.flushIntervalDelay = options.flushIntervalDelay ?? 3e4;
+		const initialDelay = options.initialFlushIntervalDelay ?? 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() {
+		if (!this.reporter) return {
+			success: false,
+			fatalError: false
+		};
+		const evaluationSnapshot = this.evaluationEventQueue.takeSnapshot();
+		return await 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 ../shared/src/LimitedMap.ts
+var LimitedMap = class extends Map {
+	limit;
+	_droppedCount = 0;
+	constructor(limit, entries) {
+		super(entries);
+		this.limit = limit;
+		this.enforceLimit();
+	}
+	set(key, value) {
+		super.set(key, value);
+		this.enforceLimit();
+		return this;
+	}
+	get droppedCount() {
+		return this._droppedCount;
+	}
+	clearAndReset() {
+		this.clear();
+		this._droppedCount = 0;
+	}
+	enforceLimit() {
+		while (this.size > this.limit) {
+			const oldestKey = this.keys().next().value;
+			if (oldestKey !== void 0) {
+				this.delete(oldestKey);
+				this._droppedCount += 1;
+			}
+		}
+	}
+};
+//#endregion
+//#region ../js-server-sdk/src/telemetry/ServerTelemetryEventCollector.ts
+const DEFAULT_CONTEXTS_LIMIT = 1e3;
+var ServerTelemetryEventCollector = class extends TelemetryEventCollector {
+	reporter;
+	_context;
+	contexts;
+	constructor(options) {
+		super(options);
+		this.reporter = new ServerEventReporter(options);
+		this.contexts = new LimitedMap(options.contextLimit ?? DEFAULT_CONTEXTS_LIMIT);
+	}
+	evaluatedConfig(payload) {
+		if (!this.collectEvents) return;
+		if (payload.context?.id) this.contexts.set(payload.context.id, payload.context);
+		const event = {
+			...payload.evaluation,
+			contextId: payload.context?.id
+		};
+		this.evaluationEventQueue.push(this.sanitizeEvaluatedConfigEvent(event));
+	}
+	sanitizeEvaluatedConfigEvent(event) {
+		return {
+			...event,
+			defaultValue: this.sanitizeValue(event.defaultValue, event.type),
+			evaluatedValue: this.sanitizeValue(event.evaluatedValue, event.type)
+		};
+	}
+	snapshotContexts() {
+		const contexts = Array.from(this.contexts.values());
+		const droppedCount = this.contexts.droppedCount;
+		this.contexts.clearAndReset();
+		return {
+			contexts,
+			droppedCount
+		};
+	}
+	async flush() {
+		if (!this.reporter) return {
+			success: false,
+			fatalError: false
+		};
+		const evaluationSnapshot = this.evaluationEventQueue.takeSnapshot();
+		const contextsSnapshot = this.snapshotContexts();
+		return await this.reporter?.report({
+			context: this._context,
+			discreteEvents: { capturedContexts: contextsSnapshot.contexts },
+			aggregatedEvents: { evaluatedConfig: this.aggregator.aggregate(evaluationSnapshot) },
+			droppedEvents: {
+				evaluatedConfig: evaluationSnapshot.droppedCount,
+				capturedContexts: contextsSnapshot.droppedCount
+			}
+		});
+	}
+};
+//#endregion
+//#region ../js-server-sdk/src/DefaultConfigDirectorClient.ts
+const defaultBaseUrl = new URL("https://server-sdk-api.configdirector.com");
+const DEFAULT_FLUSH_INTERVAL = 3e4;
+const DEFAULT_EVENT_QUEUE_LIMIT = 5e3;
+var DefaultConfigDirectorClient = class {
+	logger;
+	usageEventCollector;
+	configSet;
+	handlersMap = /* @__PURE__ */ new Map();
+	transport;
+	eventEmitter = new EventEmitter();
+	timeout;
+	ready = false;
+	readyPromise;
+	readyResolve;
+	streaming;
+	configEvaluator;
+	metaContext;
+	constructor(serverSdkKey, sdkOptions, clientOptions) {
+		this.logger = clientOptions?.logger ?? createDefaultLogger$1();
+		this.timeout = clientOptions?.connection?.timeout ?? 3e3;
+		this.metaContext = clientOptions?.metadata ?? {};
+		this.configEvaluator = new ConfigEvaluator(this.logger);
+		const baseUrl = this.parseUrl(clientOptions?.connection?.url) ?? defaultBaseUrl;
+		this.streaming = clientOptions?.connection?.streaming === false ? false : true;
+		const transportConstructor = StreamingTransport;
+		const queueLimit = clientOptions?.telemetry?.eventQueueLimit ?? DEFAULT_EVENT_QUEUE_LIMIT;
+		this.usageEventCollector = new ServerTelemetryEventCollector({
+			sdkKey: serverSdkKey,
+			logger: this.logger,
+			baseUrl,
+			flushIntervalDelay: clientOptions?.telemetry?.flushInterval ?? DEFAULT_FLUSH_INTERVAL,
+			evaluationQueueLimit: Math.ceil(queueLimit * .7),
+			contextLimit: Math.floor(queueLimit * .3),
+			urlFactory: defaultUrlFactory
+		});
+		this.transport = new transportConstructor({
+			serverSdkKey,
+			baseUrl,
+			metaContext: {
+				...clientOptions?.metadata,
+				sdkName: sdkOptions.sdkName,
+				sdkVersion: sdkOptions.sdkVersion
+			},
+			logger: this.logger
+		});
+		this.transport.on("configBundleReceived", (configBundle) => {
+			this.readyResolve?.();
+			const configKeys = Object.keys(configBundle.configs);
+			if (!this.configSet || configBundle.kind == "full") {
+				this.configSet = configBundle;
+				this.eventEmitter.emit("configsUpdated", { keys: configKeys });
+				this.updateWatchers(configBundle.configs);
+			} else {
+				this.configSet.configs = {
+					...this.configSet.configs,
+					...configBundle.configs
+				};
+				this.eventEmitter.emit("configsUpdated", { keys: configKeys });
+				this.updateWatchers(configBundle.configs);
+			}
+			this.logger.debug(`[ConfigDirectorClient] ConfigSet updated from server with ${configKeys.length} key(s)`, { keys: configKeys });
+		});
+	}
+	async initialize() {
+		try {
+			this.ready = false;
+			this.readyPromise = new Promise((resolve) => {
+				this.readyResolve = resolve;
+			}).then(() => {
+				this.ready = true;
+				this.eventEmitter.emit("clientReady");
+				this.logger.debug("[ConfigDirectorClient] Received initial payload from the server, client is ready");
+			});
+			const startTime = (/* @__PURE__ */ new Date()).getTime();
+			await this.transport.connect(this.timeout);
+			const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - startTime;
+			const remainingTimeout = this.timeout - elapsedTime;
+			if (remainingTimeout > 0) await Promise.race([this.readyPromise, new Promise((resolve) => {
+				setTimeout(() => resolve(), remainingTimeout);
+			})]);
+			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 initialization after ${this.timeout}ms. ${warningDetails}`);
+			}
+		} catch (error) {
+			this.logger.error("[ConfigDirectorClient] An error occurred during initialization: ", error);
+		}
+	}
+	updateWatchers(configsMap) {
+		Object.values(configsMap).forEach((v) => this.updateWatchersForConfig(v));
+	}
+	updateWatchersForConfig(configDefinition) {
+		this.handlersMap.get(configDefinition.key)?.forEach((h) => {
+			const value = this.getValueFromConfigDefinition(configDefinition.key, configDefinition, h.defaultValue, h.context);
+			h.handler(value);
+		});
+	}
+	watch(configKey, defaultValue, callback, context) {
+		this.validateDefaultValue(defaultValue);
+		const handlers = this.handlersMap.get(configKey);
+		const handlerWithOptions = {
+			handler: callback,
+			defaultValue,
+			requestedType: typeof defaultValue,
+			context
+		};
+		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?.splice(index, 1);
+		} else handlers.splice(0);
+	}
+	getValue(configKey, defaultValue, context) {
+		this.validateDefaultValue(defaultValue);
+		const configDefinition = this.configSet?.configs[configKey];
+		return this.getValueFromConfigDefinition(configKey, configDefinition, defaultValue, context);
+	}
+	getValueFromConfigDefinition(configKey, configDefinition, defaultValue, context) {
+		if (configDefinition) {
+			const parseResult = parseConfigValue(this.configEvaluator.evaluate(configDefinition, {
+				context,
+				metadata: this.metaContext
+			}), defaultValue);
+			this.usageEventCollector.evaluatedConfig({
+				context,
+				evaluation: {
+					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;
+		} else {
+			this.logger.debug(`[ConfigDirectorClient] No config state found for '${configKey}', returning default value '${defaultValue}'`);
+			this.usageEventCollector.evaluatedConfig({
+				context,
+				evaluation: {
+					key: configKey,
+					defaultValue,
+					requestedType: getRequestedType(defaultValue),
+					evaluatedValue: defaultValue,
+					usedDefault: true,
+					evaluationReason: "config-state-missing"
+				}
+			});
+			return defaultValue;
+		}
+	}
+	parseUrl(url) {
+		if (!url) return;
+		try {
+			return new URL(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) {
+		if (handler) this.eventEmitter.off(eventName, handler);
+		else this.eventEmitter.removeAllListeners(eventName);
+	}
+	removeAllObservers() {
+		this.logger.debug("[ConfigDirectorClient] removeAllObservers() has been called, removing all observers");
+		this.eventEmitter.removeAllListeners();
+		this.handlersMap.clear();
+	}
+	unwatchAll() {
+		this.handlersMap.clear();
+	}
+	closeConnection() {
+		this.logger.debug("[ConfigDirectorClient] closeConnection() has been called, closing connection to server");
+		this.transport.close();
+		this.ready = false;
+	}
+	dispose() {
+		this.removeAllObservers();
+		this.closeConnection();
+	}
+};
+//#endregion
+//#region src/runtime/logger.ts
+const createDefaultLogger = (level) => {
+	const logger = consola.withTag("configdirector-nuxt-sdk");
+	if (level !== void 0) logger.level = level;
+	return logger;
+};
+//#endregion
+//#region src/runtime/nitro/plugin.ts
+var plugin_default = defineNitroPlugin((nitroApp) => {
+	const runtimeConfig = useRuntimeConfig();
+	const logger = createDefaultLogger(runtimeConfig.configdirector?.logLevel);
+	if (!runtimeConfig.configdirector.serverSdkKey) {
+		const message = "The ConfigDirector serverSdkKey must be configured for the plugin to initialize. You can provide it in nuxt.config.ts under 'runtimeConfig.configdirector.serverSdkKey' or as a runtime environment variable named NUXT_CONFIGDIRECTOR_SERVER_SDK_KEY";
+		logger.error(message);
+		throw new ConfigDirectorInitializationError(message);
+	}
+	logger.debug("Initializing ConfigDirector Nitro plugin");
+	const { serverSdkKey, baseUrl } = runtimeConfig.configdirector;
+	const client = new DefaultConfigDirectorClient(serverSdkKey, {
+		sdkName: "nuxt-sdk",
+		sdkVersion: "0.1.0"
+	}, {
+		logger,
+		...baseUrl ? { connection: { url: baseUrl } } : {}
+	});
+	nitroApp.configDirectorClient = client;
+	client.initialize();
+});
+//#endregion
+export { plugin_default as default };