@configdirector/nuxt-sdk 0.1.0

package/dist/runtime/plugin.client.mjs

@@ -0,0 +1,1162 @@
+import { defineNuxtPlugin, useNuxtApp, useRuntimeConfig, useState } from "#app";
+import { readonly, shallowRef, toRaw } from "vue";
+import { consola } from "consola";
+//#region ../js-client-core/src/Emitter.ts
+var Emitter = class {
+	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 {
+	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 ../js-client-core/src/errors.ts
+const isFetchErrorFatal = (fetchError) => {
+	if (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 {
+	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-client-core/src/StreamingTransport.ts
+var StreamingTransport = class {
+	logger;
+	eventSource;
+	eventEmitter = new Emitter();
+	url;
+	timeoutTimer;
+	constructor(options) {
+		this.options = options;
+		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 ?? 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;
+	}
+	on(name, handler) {
+		this.eventEmitter.on(name, handler);
+	}
+	off(name, handler) {
+		this.eventEmitter.off(name, handler);
+	}
+	clear() {
+		this.eventEmitter.clear();
+	}
+	close() {
+		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 {
+		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-client-core/src/logger.ts
+var LogMessageDecorator = class {
+	decorateMessage(message) {
+		return `[ConfigDirector:js-client-sdk] ${message}`;
+	}
+};
+const createDefaultLogger$1 = (level, messageDecorator) => {
+	return new DefaultConsoleLogger(level ?? "warn", 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 {
+	logger;
+	eventEmitter = new Emitter();
+	url;
+	fatalError = false;
+	constructor(options) {
+		this.options = options;
+		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) {
+		const status = responseStatus ?? 0;
+		return new ConfigDirectorConnectionError(`${`Connection failed with status: ${responseStatus ?? "unknown"}`}${(errorBody?.trim()?.length ?? 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?.toString());
+const parseUrl = (url) => {
+	if (!url) return;
+	try {
+		return new URL(url);
+	} catch (error) {
+		throw new ConfigDirectorValidationError(`Invalid URL '${url}'. Parsing failed: ${error}`);
+	}
+};
+//#endregion
+//#region ../js-client-core/src/DefaultConfigDirectorClient.ts
+const MAX_EXPONENTIAL_DELAY = 9;
+var DefaultConfigDirectorClient = class {
+	logger;
+	telemetryClient;
+	configSet;
+	handlersMap = /* @__PURE__ */ new Map();
+	transport;
+	eventEmitter = new Emitter();
+	timeout;
+	timeoutTimer;
+	ready = false;
+	initializing = false;
+	readyPromise;
+	readyResolve;
+	currentContext;
+	streaming;
+	constructor(telemetryClient, clientSdkKey, sdkOptions, clientOptions, internalClientOptions) {
+		this.logger = clientOptions?.logger ?? createDefaultLogger$1();
+		this.timeout = clientOptions?.connection?.timeout ?? 3e3;
+		const urlFactory = internalClientOptions?.urlFactory ?? defaultUrlFactory;
+		const baseUrl = this.parseUrl(clientOptions?.connection?.url, urlFactory) ?? "https://client-sdk-api.configdirector.com";
+		this.streaming = clientOptions?.connection?.streaming === false ? false : true;
+		const transportConstructor = this.streaming ? StreamingTransport : PullTransport;
+		this.telemetryClient = telemetryClient;
+		this.transport = new transportConstructor({
+			clientSdkKey,
+			baseUrl,
+			resolveUrl: urlFactory,
+			metaContext: {
+				...clientOptions?.metadata,
+				sdkName: sdkOptions.sdkName,
+				sdkVersion: sdkOptions.sdkVersion,
+				userAgent: navigator?.userAgent
+			},
+			logger: this.logger,
+			fetch: internalClientOptions?.fetch,
+			connectionRetryDelay: internalClientOptions?.connectionRetryDelay ?? ((attempt) => {
+				return Math.pow(2, Math.min(attempt, MAX_EXPONENTIAL_DELAY)) * 1e3;
+			})
+		});
+		this.transport.on("configSetReceived", (configSet) => {
+			this.readyResolve?.();
+			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) {
+		this.initializing = true;
+		await this.connectToTransport(context, "initialization");
+	}
+	async updateContext(context) {
+		await this.connectToTransport(context, "context update");
+	}
+	get context() {
+		return this.currentContext;
+	}
+	async connectToTransport(context, caller) {
+		try {
+			this.ready = false;
+			this.readyPromise = new Promise((resolve) => {
+				this.readyResolve = resolve;
+			}).then(() => {
+				this.ready = true;
+				this.initializing = false;
+				this.eventEmitter.emit("clientReady", { action: caller });
+				this.logger.debug("[ConfigDirectorClient] Received initial payload from the server, client is ready");
+			});
+			const startTime = (/* @__PURE__ */ new Date()).getTime();
+			await this.transport.connect(context ?? {}, this.timeout);
+			this.currentContext = context;
+			this.telemetryClient.updateContext(context);
+			this.eventEmitter.emit("contextUpdated", { context });
+			const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - startTime;
+			const remainingTimeout = this.timeout - elapsedTime;
+			clearTimeout(this.timeoutTimer);
+			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) {
+		this.handlersMap.get(configState.key)?.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?.splice(index, 1);
+		} else handlers.splice(0);
+	}
+	getValue(configKey, defaultValue) {
+		this.validateDefaultValue(defaultValue);
+		const configState = this.configSet?.configs[configKey];
+		return this.getValueFromConfigState(configKey, configState, defaultValue);
+	}
+	getValueFromConfigState(configKey, configState, defaultValue) {
+		if (!configState) {
+			this.logger.debug(`[ConfigDirectorClient] No config state found for '${configKey}', returning default value '${defaultValue}'`);
+			this.telemetryClient.evaluatedConfig({
+				contextId: 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.currentContext?.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;
+	}
+	get isInitializing() {
+		return this.initializing;
+	}
+	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() {
+		this.logger.debug("[ConfigDirectorClient] close() has been called, closing connection to server");
+		clearTimeout(this.timeoutTimer);
+		this.readyResolve?.();
+		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++) {
+		hash = (hash << 5) + hash + (bytes[i] ?? 0);
+		hash = hash >>> 0;
+	}
+	return hash;
+};
+//#endregion
+//#region ../js-browser-client/src/telemetry/WebWorkerTelemetryClient.ts
+var WebWorkerTelemetryClient = class {
+	logger;
+	worker;
+	closePromise;
+	closeResolve;
+	visibilityHandler;
+	constructor(options) {
+		this.logger = options.logger;
+		const initializeMessage = {
+			type: "Initialize",
+			payload: {
+				sdkKey: options.sdkKey,
+				baseUrl: options.baseUrl.toString(),
+				evaluationQueueLimit: options.evaluationQueueLimit ?? 1e3,
+				initialFlushIntervalDelay: options.initialFlushIntervalDelay ?? 5e3,
+				flushIntervalDelay: options.flushIntervalDelay ?? 3e4
+			}
+		};
+		this.worker = new Worker(URL.createObjectURL(new Blob(["(function(){let e=(e,n)=>{if(n===`json`)try{return t(JSON.stringify(e))}catch{return e.toString().slice(0,500)}return e.toString().slice(0,500)},t=e=>n(new TextEncoder().encode(e)).toString(16).padStart(8,`0`),n=e=>{let t=5381;for(let n=0;n<e.length;n++)t=(t<<5)+t+(e[n]??0),t>>>=0;return t},r=e=>{let t=Object.keys(e);if(t.length==0)return!0;for(let n of t)if((e[n]?.length??0)>0)return!1;return!0},i=e=>{if(!e)return!0;let t=Object.keys(e);if(t.length==0)return!0;for(let n of t)if((e[n]??0)>0)return!1;return!0},a=async(e,t,n,r)=>{let i=new AbortController,a=setTimeout(()=>{r.debug(`[fetchWithTimeout] Reached timeout, aborting request`),i.abort()},e);try{let e=await fetch(typeof t==`string`||t instanceof Request?t:t.toString(),{...n,signal:i.signal});return clearTimeout(a),e}catch(e){throw r.warn(`[fetchWithTimeout] Fetch error: `,e),clearTimeout(a),e}},o=e=>e?.name===`NotAllowedError`?!0:e instanceof TypeError;var s=class{constructor(e){this.executeRequests=!0,this.sdkKey=e.sdkKey,this.logger=e.logger,this.url=e.urlFactory(`client/telemetry/v1`,e.baseUrl)}async report({context:e,discreteEvents:t,aggregatedEvents:n,droppedEvents:r}){if(!this.executeRequests)return{success:!1,fatalError:!0};let i={clientSdkKey:this.sdkKey,context:e,discreteEvents:t,aggregatedEvents:n,droppedEvents:r};if(this.isReportEmpty(i))return{success:!0,fatalError:!1};let a=await this.sendReport(i);return a.fatalError&&(this.executeRequests=!1),a}isReportEmpty(e){return r(e.discreteEvents)&&r(e.aggregatedEvents)&&i(e.droppedEvents)}async sendReport(e){try{let t=await a(5e3,this.url,{method:`POST`,body:JSON.stringify(e),keepalive:!0},this.logger),n=this.isStatusFatal(t.status);return n&&this.logger.warn(`[EventReporter] Received a fatal status response (${t.status}) from the telemetry endpoint. No more telemetry data will be sent.`),{success:t.ok,fatalError:n}}catch(e){let t=o(e);return this.logger.warn(`[EventReporter] Error attempting to send telemetry data: ${e}`,{error:e}),{success:!1,fatalError:t}}}isStatusFatal(e){return!!e&&e>=400&&e<500}},c=class{aggregate(e){if(e.events.length==0)return[];let t=new Map;for(let n of e.events){let e=JSON.stringify(n),r=t.get(e)?.count||0;t.set(e,{event:n,count:r+1})}return Array.from(t).map(([,t])=>({startTime:e.startTime,endTime:e.endTime,count:t.count,event:t.event}))}},l=class{constructor(e){this._events=[],this._droppedEventCount=0,this.limit=e??1e3}get events(){return this._events}get reachedLimit(){return this._events.length>=this.limit}get droppedEventCount(){return this._droppedEventCount}push(...e){this.startTime||=new Date;let t=Math.max(0,e.length-this.limit),n=e.slice(t,e.length);if(this._droppedEventCount+=t,this._events.length+n.length>this.limit){let e=this._events.length+n.length-this.limit;this._events.splice(0,e),this._droppedEventCount+=e}return this._events.push(...n)}takeSnapshot(){let e=new Date,t=this.startTime??e,n=this._events.splice(0),r=this._droppedEventCount;return this.startTime=void 0,this._droppedEventCount=0,{startTime:t,endTime:e,events:n,droppedCount:r}}clear(){this._events=[],this.startTime=void 0,this._droppedEventCount=0}},u=class{constructor(e){this.aggregator=new c,this.collectEvents=!0,this.logger=e.logger,this.evaluationEventQueue=new l(e.evaluationQueueLimit??1e3),this.flushIntervalDelay=e.flushIntervalDelay??3e4;let t=e.initialFlushIntervalDelay??5e3;this.flushTimeout=setTimeout(()=>this.flushAndScheduleNext(),t)}sanitizeValue(t,n){return e(t,n)}async flushAndScheduleNext(){(await this.flush()).fatalError?(this.collectEvents=!1,this.close(),this.logger.warn(`[TelemetryEventCollector] Received a fatal error from telemetry collection. No longer collecting events.`)):this.flushTimeout=setTimeout(()=>this.flushAndScheduleNext(),this.flushIntervalDelay)}async flush(){if(!this.reporter)return{success:!1,fatalError:!1};let e=this.evaluationEventQueue.takeSnapshot();return await this.reporter?.report({context:this._context,discreteEvents:{},aggregatedEvents:{evaluatedConfig:this.aggregator.aggregate(e)},droppedEvents:{evaluatedConfig:e.droppedCount}})}cancelScheduledFlush(){clearTimeout(this.flushTimeout)}async close(){this.collectEvents=!1,clearTimeout(this.flushTimeout),await this.flush(),this.evaluationEventQueue.clear()}dispose(){this.close()}},d=class extends u{constructor(e){super(e),this.reporter=new s(e)}async updateContext(e){this.cancelScheduledFlush(),await this.flush(),this._context=e,await this.flushAndScheduleNext()}evaluatedConfig(e){this.collectEvents&&this.evaluationEventQueue.push(e)}async forceFlush(){this.cancelScheduledFlush(),await this.flushAndScheduleNext()}};let f=(e,t)=>new URL(e,t?.toString()),p,m=(e,t,...n)=>({type:`Log`,payload:{level:e,message:t,args:n}}),h=e=>{try{self.postMessage(e)}catch{self.postMessage(m(e.payload.level,e.payload.message))}},g={debug:function(e,...t){h(m(`debug`,e,t))},info:function(e,...t){h(m(`info`,e,t))},warn:function(e,...t){h(m(`warn`,e,t))},error:function(e,...t){h(m(`error`,e,t))}};addEventListener(`message`,e=>{let t=e.data;if(t.type!=`Initialize`&&!p){g.info(`[TelemetryWorker] Ignoring ${t.type} because no collector is configured`);return}switch(g.debug(`[TelemetryWorker] Received '${t.type}' event:`,t),t.type){case`Initialize`:p=new d({...t.payload,baseUrl:f(t.payload.baseUrl),urlFactory:f,logger:g});break;case`EvaluatedConfigEvent`:p?.evaluatedConfig(t.payload);break;case`UpdateContext`:p?.updateContext(t.payload.context);break;case`Flush`:p?.forceFlush();break;case`Close`:(p?.close()??Promise.resolve()).then(()=>{self.postMessage({type:`Closed`}),self.close()});break}})})();"], { type: "application/javascript" })));
+		this.worker.onmessage = (message) => {
+			this.handleWorkerEvent(message.data);
+		};
+		this.worker.postMessage(initializeMessage);
+		this.visibilityHandler = () => {
+			if (document.visibilityState === "hidden") this.flush();
+		};
+		try {
+			document.addEventListener("visibilitychange", this.visibilityHandler);
+		} catch (error) {
+			this.logger.warn("[TelemetryEventCollector] Could not configure 'visibilitychange' listener: ", error);
+		}
+	}
+	async updateContext(value) {
+		const updateContextMessage = {
+			type: "UpdateContext",
+			payload: { context: value }
+		};
+		this.worker.postMessage(updateContextMessage);
+	}
+	evaluatedConfig(event) {
+		const evaluatedConfigMessage = {
+			type: "EvaluatedConfigEvent",
+			payload: this.sanitizeEvaluatedConfigEvent(event)
+		};
+		this.worker.postMessage(evaluatedConfigMessage);
+	}
+	sanitizeEvaluatedConfigEvent(event) {
+		return {
+			...event,
+			defaultValue: sanitizeValue(event.defaultValue, event.type),
+			evaluatedValue: sanitizeValue(event.evaluatedValue, event.type)
+		};
+	}
+	handleWorkerEvent(event) {
+		if (event.type === "Closed") {
+			this.closeResolve?.();
+			return;
+		}
+		if (!event.payload?.level || !event.payload?.message) return;
+		const { level, message, args } = event.payload;
+		switch (level) {
+			case "debug":
+				this.logger.debug(message, ...args);
+				break;
+			case "info":
+				this.logger.info(message, ...args);
+				break;
+			case "warn":
+				this.logger.warn(message, ...args);
+				break;
+			case "error":
+				this.logger.warn(message, ...args);
+				break;
+		}
+	}
+	flush() {
+		this.worker.postMessage({ type: "Flush" });
+	}
+	close() {
+		if (this.closePromise) return this.closePromise;
+		return this.performClose();
+	}
+	performClose() {
+		document.removeEventListener("visibilitychange", this.visibilityHandler);
+		this.closePromise = new Promise((resolve) => {
+			this.closeResolve = resolve;
+			this.worker.postMessage({ type: "Close" });
+		});
+		return this.closePromise;
+	}
+};
+//#endregion
+//#region ../js-browser-client/src/BrowserConfigDirectorClient.ts
+const createBrowserClient = (clientSdkKey, sdkOptions, clientOptions) => {
+	const logger = clientOptions?.logger ?? createDefaultLogger$1();
+	return new DefaultConfigDirectorClient(new WebWorkerTelemetryClient({
+		sdkKey: clientSdkKey,
+		logger,
+		baseUrl: parseUrl(clientOptions?.connection?.url) ?? "https://client-sdk-api.configdirector.com",
+		urlFactory: defaultUrlFactory
+	}), clientSdkKey, sdkOptions, {
+		...clientOptions,
+		logger
+	});
+};
+//#endregion
+//#region src/runtime/app/composables/useConfigDirectorClient.ts
+const useConfigDirectorClient = () => {
+	const { $configDirectorClient } = useNuxtApp();
+	return { client: $configDirectorClient };
+};
+//#endregion
+//#region src/runtime/app/composables/useConfigDirectorContext.ts
+const DEFAULT_TIMEOUT = 3e3;
+const getEffectiveTimeout = (option) => {
+	return option && option > 0 ? option : DEFAULT_TIMEOUT;
+};
+const useConfigDirectorContext = () => {
+	const state = useState("configdirector-context");
+	const { client } = useConfigDirectorClient();
+	const updateContext = async (context, options) => {
+		const rawContext = toRaw(context);
+		const oldContext = JSON.stringify(state.value);
+		const newContext = JSON.stringify(rawContext);
+		state.value = rawContext;
+		if (oldContext != newContext) {
+			const timeout = getEffectiveTimeout(options?.timeoutMilliseconds);
+			await Promise.race([client.updateContext(rawContext), new Promise((resolve) => {
+				setTimeout(() => resolve(), timeout);
+			})]);
+		}
+	};
+	return {
+		context: readonly(state),
+		updateContext
+	};
+};
+//#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/plugin.client.ts
+var plugin_client_default = defineNuxtPlugin((nuxtApp) => {
+	const runtimeConfig = useRuntimeConfig();
+	const logger = createDefaultLogger(runtimeConfig.public?.configdirector?.logLevel);
+	if (!runtimeConfig.public?.configdirector?.clientSdkKey) {
+		const message = "The ConfigDirector clientSdkKey must be configured for the plugin to initialize. You can provide it in nuxt.config.ts under 'runtimeConfig.public.configdirector.clientSdkKey' or as a runtime environment variable named NUXT_PUBLIC_CONFIGDIRECTOR_CLIENT_SDK_KEY";
+		logger.error(message);
+		throw new ConfigDirectorInitializationError(message);
+	}
+	logger.debug("Installed ConfigDirector Nuxt plugin");
+	const { clientSdkKey, appName, appVersion, baseUrl } = runtimeConfig.public.configdirector;
+	const client = createBrowserClient(clientSdkKey, {
+		sdkName: "nuxt-sdk",
+		sdkVersion: "0.1.0"
+	}, {
+		metadata: {
+			appName,
+			appVersion
+		},
+		connection: {
+			timeout: 2e3,
+			...baseUrl ? { url: baseUrl } : {}
+		},
+		logger
+	});
+	const readyStatus = shallowRef(client.isReady ? "ready" : "loading");
+	client.on("clientReady", () => {
+		readyStatus.value = "ready";
+	});
+	nuxtApp.hooks.hook("app:created", async () => {
+		logger.debug("Initializing browser client");
+		const { context } = useConfigDirectorContext();
+		await client.initialize(toRaw(context.value));
+		if (!client.isReady) readyStatus.value = "default";
+		logger.debug(`Browser client initialization awaited, ready status: ${client.isReady}`);
+	});
+	return { provide: {
+		configDirectorClient: client,
+		configDirectorClientReadyStatus: readonly(readyStatus)
+	} };
+});
+//#endregion
+export { plugin_client_default as default };