@luzmo/analytics-components-kit 1.0.1-alpha.15 → 1.0.1-alpha.150

package/components/data-broker-cLR-t5LM.js

@@ -0,0 +1,1609 @@
+/*! * A kit of modern Luzmo Web Components for analytics in your web application.
+ * 
+ * Copyright © 2026 Luzmo
+ * All rights reserved.
+ * Luzmo web components (“Luzmo Web Components”)
+ * must be used according to the Luzmo Terms of Service.
+ * This license allows users with a current active Luzmo account
+ * to use the Luzmo Web Components. This license terminates
+ * automatically if a user no longer has an active Luzmo account.
+ * Please view the Luzmo Terms of Service at: https://www.luzmo.com/information-pages/terms-of-use.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * */
+import { c as validateUuids, s as isValidUuid } from "./type-check-CVgyxvdF.js";
+var Subscribable = class {
+	constructor() {
+		this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+	}
+	subscribe(u) {
+		return this.listeners.add(u), this.onSubscribe(), () => {
+			this.listeners.delete(u), this.onUnsubscribe();
+		};
+	}
+	hasListeners() {
+		return this.listeners.size > 0;
+	}
+	onSubscribe() {}
+	onUnsubscribe() {}
+}, defaultTimeoutProvider = {
+	setTimeout: (u, z) => setTimeout(u, z),
+	clearTimeout: (u) => clearTimeout(u),
+	setInterval: (u, z) => setInterval(u, z),
+	clearInterval: (u) => clearInterval(u)
+}, timeoutManager = new class {
+	#e = defaultTimeoutProvider;
+	setTimeoutProvider(u) {
+		this.#e = u;
+	}
+	setTimeout(u, z) {
+		return this.#e.setTimeout(u, z);
+	}
+	clearTimeout(u) {
+		this.#e.clearTimeout(u);
+	}
+	setInterval(u, z) {
+		return this.#e.setInterval(u, z);
+	}
+	clearInterval(u) {
+		this.#e.clearInterval(u);
+	}
+}();
+function systemSetTimeoutZero(u) {
+	setTimeout(u, 0);
+}
+var isServer = typeof window > "u" || "Deno" in globalThis;
+function noop() {}
+function functionalUpdate(u, z) {
+	return typeof u == "function" ? u(z) : u;
+}
+function isValidTimeout(u) {
+	return typeof u == "number" && u >= 0 && u !== Infinity;
+}
+function timeUntilStale(u, z) {
+	return Math.max(u + (z || 0) - Date.now(), 0);
+}
+function resolveStaleTime(u, z) {
+	return typeof u == "function" ? u(z) : u;
+}
+function resolveEnabled(u, z) {
+	return typeof u == "function" ? u(z) : u;
+}
+function matchQuery(u, z) {
+	let { type: B = "all", exact: V, fetchStatus: H, predicate: U, queryKey: W, stale: G } = u;
+	if (W) {
+		if (V) {
+			if (z.queryHash !== hashQueryKeyByOptions(W, z.options)) return !1;
+		} else if (!partialMatchKey(z.queryKey, W)) return !1;
+	}
+	if (B !== "all") {
+		let u = z.isActive();
+		if (B === "active" && !u || B === "inactive" && u) return !1;
+	}
+	return !(typeof G == "boolean" && z.isStale() !== G || H && H !== z.state.fetchStatus || U && !U(z));
+}
+function matchMutation(u, z) {
+	let { exact: B, status: V, predicate: H, mutationKey: U } = u;
+	if (U) {
+		if (!z.options.mutationKey) return !1;
+		if (B) {
+			if (hashKey(z.options.mutationKey) !== hashKey(U)) return !1;
+		} else if (!partialMatchKey(z.options.mutationKey, U)) return !1;
+	}
+	return !(V && z.state.status !== V || H && !H(z));
+}
+function hashQueryKeyByOptions(u, z) {
+	return (z?.queryKeyHashFn || hashKey)(u);
+}
+function hashKey(u) {
+	return JSON.stringify(u, (u, z) => isPlainObject(z) ? Object.keys(z).sort().reduce((u, B) => (u[B] = z[B], u), {}) : z);
+}
+function partialMatchKey(u, z) {
+	return u === z ? !0 : typeof u == typeof z && u && z && typeof u == "object" && typeof z == "object" ? Object.keys(z).every((B) => partialMatchKey(u[B], z[B])) : !1;
+}
+var hasOwn = Object.prototype.hasOwnProperty;
+function replaceEqualDeep(u, z) {
+	if (u === z) return u;
+	let B = isPlainArray(u) && isPlainArray(z);
+	if (!B && !(isPlainObject(u) && isPlainObject(z))) return z;
+	let V = (B ? u : Object.keys(u)).length, H = B ? z : Object.keys(z), U = H.length, W = B ? Array(U) : {}, G = 0;
+	for (let K = 0; K < U; K++) {
+		let U = B ? K : H[K], q = u[U], J = z[U];
+		if (q === J) {
+			W[U] = q, (B ? K < V : hasOwn.call(u, U)) && G++;
+			continue;
+		}
+		if (q === null || J === null || typeof q != "object" || typeof J != "object") {
+			W[U] = J;
+			continue;
+		}
+		let Y = replaceEqualDeep(q, J);
+		W[U] = Y, Y === q && G++;
+	}
+	return V === U && G === V ? u : W;
+}
+function isPlainArray(u) {
+	return Array.isArray(u) && u.length === Object.keys(u).length;
+}
+function isPlainObject(u) {
+	if (!hasObjectPrototype(u)) return !1;
+	let z = u.constructor;
+	if (z === void 0) return !0;
+	let B = z.prototype;
+	return !(!hasObjectPrototype(B) || !B.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(u) !== Object.prototype);
+}
+function hasObjectPrototype(u) {
+	return Object.prototype.toString.call(u) === "[object Object]";
+}
+function sleep(u) {
+	return new Promise((z) => {
+		timeoutManager.setTimeout(z, u);
+	});
+}
+function replaceData(u, z, B) {
+	return typeof B.structuralSharing == "function" ? B.structuralSharing(u, z) : B.structuralSharing === !1 ? z : replaceEqualDeep(u, z);
+}
+function addToEnd(u, z, B = 0) {
+	let V = [...u, z];
+	return B && V.length > B ? V.slice(1) : V;
+}
+function addToStart(u, z, B = 0) {
+	let V = [z, ...u];
+	return B && V.length > B ? V.slice(0, -1) : V;
+}
+var skipToken = Symbol();
+function ensureQueryFn(u, z) {
+	return !u.queryFn && z?.initialPromise ? () => z.initialPromise : !u.queryFn || u.queryFn === skipToken ? () => Promise.reject(/* @__PURE__ */ Error(`Missing queryFn: '${u.queryHash}'`)) : u.queryFn;
+}
+function addConsumeAwareSignal(u, z, B) {
+	let V = !1, H;
+	return Object.defineProperty(u, "signal", {
+		enumerable: !0,
+		get: () => (H ??= z(), V ? H : (V = !0, H.aborted ? B() : H.addEventListener("abort", B, { once: !0 }), H))
+	}), u;
+}
+var focusManager = new class extends Subscribable {
+	#e;
+	#t;
+	#n;
+	constructor() {
+		super(), this.#n = (u) => {
+			if (!isServer && window.addEventListener) {
+				let z = () => u();
+				return window.addEventListener("visibilitychange", z, !1), () => {
+					window.removeEventListener("visibilitychange", z);
+				};
+			}
+		};
+	}
+	onSubscribe() {
+		this.#t || this.setEventListener(this.#n);
+	}
+	onUnsubscribe() {
+		this.hasListeners() || (this.#t?.(), this.#t = void 0);
+	}
+	setEventListener(u) {
+		this.#n = u, this.#t?.(), this.#t = u((u) => {
+			typeof u == "boolean" ? this.setFocused(u) : this.onFocus();
+		});
+	}
+	setFocused(u) {
+		this.#e !== u && (this.#e = u, this.onFocus());
+	}
+	onFocus() {
+		let u = this.isFocused();
+		this.listeners.forEach((z) => {
+			z(u);
+		});
+	}
+	isFocused() {
+		return typeof this.#e == "boolean" ? this.#e : globalThis.document?.visibilityState !== "hidden";
+	}
+}();
+function pendingThenable() {
+	let u, z, B = new Promise((B, V) => {
+		u = B, z = V;
+	});
+	B.status = "pending", B.catch(() => {});
+	function V(u) {
+		Object.assign(B, u), delete B.resolve, delete B.reject;
+	}
+	return B.resolve = (z) => {
+		V({
+			status: "fulfilled",
+			value: z
+		}), u(z);
+	}, B.reject = (u) => {
+		V({
+			status: "rejected",
+			reason: u
+		}), z(u);
+	}, B;
+}
+var defaultScheduler = systemSetTimeoutZero;
+function createNotifyManager() {
+	let u = [], z = 0, B = (u) => {
+		u();
+	}, V = (u) => {
+		u();
+	}, H = defaultScheduler, U = (V) => {
+		z ? u.push(V) : H(() => {
+			B(V);
+		});
+	}, W = () => {
+		let z = u;
+		u = [], z.length && H(() => {
+			V(() => {
+				z.forEach((u) => {
+					B(u);
+				});
+			});
+		});
+	};
+	return {
+		batch: (u) => {
+			let B;
+			z++;
+			try {
+				B = u();
+			} finally {
+				z--, z || W();
+			}
+			return B;
+		},
+		batchCalls: (u) => (...z) => {
+			U(() => {
+				u(...z);
+			});
+		},
+		schedule: U,
+		setNotifyFunction: (u) => {
+			B = u;
+		},
+		setBatchNotifyFunction: (u) => {
+			V = u;
+		},
+		setScheduler: (u) => {
+			H = u;
+		}
+	};
+}
+var notifyManager = createNotifyManager(), onlineManager = new class extends Subscribable {
+	#e = !0;
+	#t;
+	#n;
+	constructor() {
+		super(), this.#n = (u) => {
+			if (!isServer && window.addEventListener) {
+				let z = () => u(!0), B = () => u(!1);
+				return window.addEventListener("online", z, !1), window.addEventListener("offline", B, !1), () => {
+					window.removeEventListener("online", z), window.removeEventListener("offline", B);
+				};
+			}
+		};
+	}
+	onSubscribe() {
+		this.#t || this.setEventListener(this.#n);
+	}
+	onUnsubscribe() {
+		this.hasListeners() || (this.#t?.(), this.#t = void 0);
+	}
+	setEventListener(u) {
+		this.#n = u, this.#t?.(), this.#t = u(this.setOnline.bind(this));
+	}
+	setOnline(u) {
+		this.#e !== u && (this.#e = u, this.listeners.forEach((z) => {
+			z(u);
+		}));
+	}
+	isOnline() {
+		return this.#e;
+	}
+}();
+function defaultRetryDelay(u) {
+	return Math.min(1e3 * 2 ** u, 3e4);
+}
+function canFetch(u) {
+	return (u ?? "online") === "online" ? onlineManager.isOnline() : !0;
+}
+var CancelledError = class extends Error {
+	constructor(u) {
+		super("CancelledError"), this.revert = u?.revert, this.silent = u?.silent;
+	}
+};
+function createRetryer(u) {
+	let z = !1, B = 0, V, H = pendingThenable(), U = () => H.status !== "pending", G = (z) => {
+		if (!U()) {
+			let B = new CancelledError(z);
+			Z(B), u.onCancel?.(B);
+		}
+	}, K = () => {
+		z = !0;
+	}, q = () => {
+		z = !1;
+	}, J = () => focusManager.isFocused() && (u.networkMode === "always" || onlineManager.isOnline()) && u.canRun(), Y = () => canFetch(u.networkMode) && u.canRun(), X = (u) => {
+		U() || (V?.(), H.resolve(u));
+	}, Z = (u) => {
+		U() || (V?.(), H.reject(u));
+	}, Q = () => new Promise((z) => {
+		V = (u) => {
+			(U() || J()) && z(u);
+		}, u.onPause?.();
+	}).then(() => {
+		V = void 0, U() || u.onContinue?.();
+	}), $ = () => {
+		if (U()) return;
+		let V, H = B === 0 ? u.initialPromise : void 0;
+		try {
+			V = H ?? u.fn();
+		} catch (u) {
+			V = Promise.reject(u);
+		}
+		Promise.resolve(V).then(X).catch((V) => {
+			if (U()) return;
+			let H = u.retry ?? (isServer ? 0 : 3), G = u.retryDelay ?? defaultRetryDelay, K = typeof G == "function" ? G(B, V) : G, q = H === !0 || typeof H == "number" && B < H || typeof H == "function" && H(B, V);
+			if (z || !q) {
+				Z(V);
+				return;
+			}
+			B++, u.onFail?.(B, V), sleep(K).then(() => J() ? void 0 : Q()).then(() => {
+				z ? Z(V) : $();
+			});
+		});
+	};
+	return {
+		promise: H,
+		status: () => H.status,
+		cancel: G,
+		continue: () => (V?.(), H),
+		cancelRetry: K,
+		continueRetry: q,
+		canStart: Y,
+		start: () => (Y() ? $() : Q().then($), H)
+	};
+}
+var Removable = class {
+	#e;
+	destroy() {
+		this.clearGcTimeout();
+	}
+	scheduleGc() {
+		this.clearGcTimeout(), isValidTimeout(this.gcTime) && (this.#e = timeoutManager.setTimeout(() => {
+			this.optionalRemove();
+		}, this.gcTime));
+	}
+	updateGcTime(u) {
+		this.gcTime = Math.max(this.gcTime || 0, u ?? (isServer ? Infinity : 300 * 1e3));
+	}
+	clearGcTimeout() {
+		this.#e &&= (timeoutManager.clearTimeout(this.#e), void 0);
+	}
+}, Query = class extends Removable {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a;
+	#o;
+	constructor(u) {
+		super(), this.#o = !1, this.#a = u.defaultOptions, this.setOptions(u.options), this.observers = [], this.#r = u.client, this.#n = this.#r.getQueryCache(), this.queryKey = u.queryKey, this.queryHash = u.queryHash, this.#e = getDefaultState$1(this.options), this.state = u.state ?? this.#e, this.scheduleGc();
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	get promise() {
+		return this.#i?.promise;
+	}
+	setOptions(u) {
+		if (this.options = {
+			...this.#a,
+			...u
+		}, this.updateGcTime(this.options.gcTime), this.state && this.state.data === void 0) {
+			let u = getDefaultState$1(this.options);
+			u.data !== void 0 && (this.setState(successState(u.data, u.dataUpdatedAt)), this.#e = u);
+		}
+	}
+	optionalRemove() {
+		!this.observers.length && this.state.fetchStatus === "idle" && this.#n.remove(this);
+	}
+	setData(u, z) {
+		let B = replaceData(this.state.data, u, this.options);
+		return this.#s({
+			data: B,
+			type: "success",
+			dataUpdatedAt: z?.updatedAt,
+			manual: z?.manual
+		}), B;
+	}
+	setState(u, z) {
+		this.#s({
+			type: "setState",
+			state: u,
+			setStateOptions: z
+		});
+	}
+	cancel(u) {
+		let z = this.#i?.promise;
+		return this.#i?.cancel(u), z ? z.then(noop).catch(noop) : Promise.resolve();
+	}
+	destroy() {
+		super.destroy(), this.cancel({ silent: !0 });
+	}
+	reset() {
+		this.destroy(), this.setState(this.#e);
+	}
+	isActive() {
+		return this.observers.some((u) => resolveEnabled(u.options.enabled, this) !== !1);
+	}
+	isDisabled() {
+		return this.getObserversCount() > 0 ? !this.isActive() : this.options.queryFn === skipToken || this.state.dataUpdateCount + this.state.errorUpdateCount === 0;
+	}
+	isStatic() {
+		return this.getObserversCount() > 0 ? this.observers.some((u) => resolveStaleTime(u.options.staleTime, this) === "static") : !1;
+	}
+	isStale() {
+		return this.getObserversCount() > 0 ? this.observers.some((u) => u.getCurrentResult().isStale) : this.state.data === void 0 || this.state.isInvalidated;
+	}
+	isStaleByTime(u = 0) {
+		return this.state.data === void 0 ? !0 : u === "static" ? !1 : this.state.isInvalidated ? !0 : !timeUntilStale(this.state.dataUpdatedAt, u);
+	}
+	onFocus() {
+		this.observers.find((u) => u.shouldFetchOnWindowFocus())?.refetch({ cancelRefetch: !1 }), this.#i?.continue();
+	}
+	onOnline() {
+		this.observers.find((u) => u.shouldFetchOnReconnect())?.refetch({ cancelRefetch: !1 }), this.#i?.continue();
+	}
+	addObserver(u) {
+		this.observers.includes(u) || (this.observers.push(u), this.clearGcTimeout(), this.#n.notify({
+			type: "observerAdded",
+			query: this,
+			observer: u
+		}));
+	}
+	removeObserver(u) {
+		this.observers.includes(u) && (this.observers = this.observers.filter((z) => z !== u), this.observers.length || (this.#i && (this.#o ? this.#i.cancel({ revert: !0 }) : this.#i.cancelRetry()), this.scheduleGc()), this.#n.notify({
+			type: "observerRemoved",
+			query: this,
+			observer: u
+		}));
+	}
+	getObserversCount() {
+		return this.observers.length;
+	}
+	invalidate() {
+		this.state.isInvalidated || this.#s({ type: "invalidate" });
+	}
+	async fetch(u, z) {
+		if (this.state.fetchStatus !== "idle" && this.#i?.status() !== "rejected") {
+			if (this.state.data !== void 0 && z?.cancelRefetch) this.cancel({ silent: !0 });
+			else if (this.#i) return this.#i.continueRetry(), this.#i.promise;
+		}
+		if (u && this.setOptions(u), !this.options.queryFn) {
+			let u = this.observers.find((u) => u.options.queryFn);
+			u && this.setOptions(u.options);
+		}
+		let B = new AbortController(), V = (u) => {
+			Object.defineProperty(u, "signal", {
+				enumerable: !0,
+				get: () => (this.#o = !0, B.signal)
+			});
+		}, H = () => {
+			let u = ensureQueryFn(this.options, z), B = (() => {
+				let u = {
+					client: this.#r,
+					queryKey: this.queryKey,
+					meta: this.meta
+				};
+				return V(u), u;
+			})();
+			return this.#o = !1, this.options.persister ? this.options.persister(u, B, this) : u(B);
+		}, U = (() => {
+			let u = {
+				fetchOptions: z,
+				options: this.options,
+				queryKey: this.queryKey,
+				client: this.#r,
+				state: this.state,
+				fetchFn: H
+			};
+			return V(u), u;
+		})();
+		this.options.behavior?.onFetch(U, this), this.#t = this.state, (this.state.fetchStatus === "idle" || this.state.fetchMeta !== U.fetchOptions?.meta) && this.#s({
+			type: "fetch",
+			meta: U.fetchOptions?.meta
+		}), this.#i = createRetryer({
+			initialPromise: z?.initialPromise,
+			fn: U.fetchFn,
+			onCancel: (u) => {
+				u instanceof CancelledError && u.revert && this.setState({
+					...this.#t,
+					fetchStatus: "idle"
+				}), B.abort();
+			},
+			onFail: (u, z) => {
+				this.#s({
+					type: "failed",
+					failureCount: u,
+					error: z
+				});
+			},
+			onPause: () => {
+				this.#s({ type: "pause" });
+			},
+			onContinue: () => {
+				this.#s({ type: "continue" });
+			},
+			retry: U.options.retry,
+			retryDelay: U.options.retryDelay,
+			networkMode: U.options.networkMode,
+			canRun: () => !0
+		});
+		try {
+			let u = await this.#i.start();
+			if (u === void 0) throw Error(`${this.queryHash} data is undefined`);
+			return this.setData(u), this.#n.config.onSuccess?.(u, this), this.#n.config.onSettled?.(u, this.state.error, this), u;
+		} catch (u) {
+			if (u instanceof CancelledError) {
+				if (u.silent) return this.#i.promise;
+				if (u.revert) {
+					if (this.state.data === void 0) throw u;
+					return this.state.data;
+				}
+			}
+			throw this.#s({
+				type: "error",
+				error: u
+			}), this.#n.config.onError?.(u, this), this.#n.config.onSettled?.(this.state.data, u, this), u;
+		} finally {
+			this.scheduleGc();
+		}
+	}
+	#s(u) {
+		this.state = ((z) => {
+			switch (u.type) {
+				case "failed": return {
+					...z,
+					fetchFailureCount: u.failureCount,
+					fetchFailureReason: u.error
+				};
+				case "pause": return {
+					...z,
+					fetchStatus: "paused"
+				};
+				case "continue": return {
+					...z,
+					fetchStatus: "fetching"
+				};
+				case "fetch": return {
+					...z,
+					...fetchState(z.data, this.options),
+					fetchMeta: u.meta ?? null
+				};
+				case "success":
+					let B = {
+						...z,
+						...successState(u.data, u.dataUpdatedAt),
+						dataUpdateCount: z.dataUpdateCount + 1,
+						...!u.manual && {
+							fetchStatus: "idle",
+							fetchFailureCount: 0,
+							fetchFailureReason: null
+						}
+					};
+					return this.#t = u.manual ? B : void 0, B;
+				case "error":
+					let V = u.error;
+					return {
+						...z,
+						error: V,
+						errorUpdateCount: z.errorUpdateCount + 1,
+						errorUpdatedAt: Date.now(),
+						fetchFailureCount: z.fetchFailureCount + 1,
+						fetchFailureReason: V,
+						fetchStatus: "idle",
+						status: "error",
+						isInvalidated: !0
+					};
+				case "invalidate": return {
+					...z,
+					isInvalidated: !0
+				};
+				case "setState": return {
+					...z,
+					...u.state
+				};
+			}
+		})(this.state), notifyManager.batch(() => {
+			this.observers.forEach((u) => {
+				u.onQueryUpdate();
+			}), this.#n.notify({
+				query: this,
+				type: "updated",
+				action: u
+			});
+		});
+	}
+};
+function fetchState(u, z) {
+	return {
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchStatus: canFetch(z.networkMode) ? "fetching" : "paused",
+		...u === void 0 && {
+			error: null,
+			status: "pending"
+		}
+	};
+}
+function successState(u, z) {
+	return {
+		data: u,
+		dataUpdatedAt: z ?? Date.now(),
+		error: null,
+		isInvalidated: !1,
+		status: "success"
+	};
+}
+function getDefaultState$1(u) {
+	let z = typeof u.initialData == "function" ? u.initialData() : u.initialData, B = z !== void 0, V = B ? typeof u.initialDataUpdatedAt == "function" ? u.initialDataUpdatedAt() : u.initialDataUpdatedAt : 0;
+	return {
+		data: z,
+		dataUpdateCount: 0,
+		dataUpdatedAt: B ? V ?? Date.now() : 0,
+		error: null,
+		errorUpdateCount: 0,
+		errorUpdatedAt: 0,
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchMeta: null,
+		isInvalidated: !1,
+		status: B ? "success" : "pending",
+		fetchStatus: "idle"
+	};
+}
+function infiniteQueryBehavior(u) {
+	return { onFetch: (z, B) => {
+		let V = z.options, H = z.fetchOptions?.meta?.fetchMore?.direction, U = z.state.data?.pages || [], W = z.state.data?.pageParams || [], G = {
+			pages: [],
+			pageParams: []
+		}, K = 0, q = async () => {
+			let B = !1, q = (u) => {
+				addConsumeAwareSignal(u, () => z.signal, () => B = !0);
+			}, J = ensureQueryFn(z.options, z.fetchOptions), Y = async (u, V, H) => {
+				if (B) return Promise.reject();
+				if (V == null && u.pages.length) return Promise.resolve(u);
+				let U = await J((() => {
+					let u = {
+						client: z.client,
+						queryKey: z.queryKey,
+						pageParam: V,
+						direction: H ? "backward" : "forward",
+						meta: z.options.meta
+					};
+					return q(u), u;
+				})()), { maxPages: W } = z.options, G = H ? addToStart : addToEnd;
+				return {
+					pages: G(u.pages, U, W),
+					pageParams: G(u.pageParams, V, W)
+				};
+			};
+			if (H && U.length) {
+				let u = H === "backward", z = u ? getPreviousPageParam : getNextPageParam, B = {
+					pages: U,
+					pageParams: W
+				};
+				G = await Y(B, z(V, B), u);
+			} else {
+				let z = u ?? U.length;
+				do {
+					let u = K === 0 ? W[0] ?? V.initialPageParam : getNextPageParam(V, G);
+					if (K > 0 && u == null) break;
+					G = await Y(G, u), K++;
+				} while (K < z);
+			}
+			return G;
+		};
+		z.options.persister ? z.fetchFn = () => z.options.persister?.(q, {
+			client: z.client,
+			queryKey: z.queryKey,
+			meta: z.options.meta,
+			signal: z.signal
+		}, B) : z.fetchFn = q;
+	} };
+}
+function getNextPageParam(u, { pages: z, pageParams: B }) {
+	let V = z.length - 1;
+	return z.length > 0 ? u.getNextPageParam(z[V], z, B[V], B) : void 0;
+}
+function getPreviousPageParam(u, { pages: z, pageParams: B }) {
+	return z.length > 0 ? u.getPreviousPageParam?.(z[0], z, B[0], B) : void 0;
+}
+var Mutation = class extends Removable {
+	#e;
+	#t;
+	#n;
+	#r;
+	constructor(u) {
+		super(), this.#e = u.client, this.mutationId = u.mutationId, this.#n = u.mutationCache, this.#t = [], this.state = u.state || getDefaultState(), this.setOptions(u.options), this.scheduleGc();
+	}
+	setOptions(u) {
+		this.options = u, this.updateGcTime(this.options.gcTime);
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	addObserver(u) {
+		this.#t.includes(u) || (this.#t.push(u), this.clearGcTimeout(), this.#n.notify({
+			type: "observerAdded",
+			mutation: this,
+			observer: u
+		}));
+	}
+	removeObserver(u) {
+		this.#t = this.#t.filter((z) => z !== u), this.scheduleGc(), this.#n.notify({
+			type: "observerRemoved",
+			mutation: this,
+			observer: u
+		});
+	}
+	optionalRemove() {
+		this.#t.length || (this.state.status === "pending" ? this.scheduleGc() : this.#n.remove(this));
+	}
+	continue() {
+		return this.#r?.continue() ?? this.execute(this.state.variables);
+	}
+	async execute(u) {
+		let z = () => {
+			this.#i({ type: "continue" });
+		}, B = {
+			client: this.#e,
+			meta: this.options.meta,
+			mutationKey: this.options.mutationKey
+		};
+		this.#r = createRetryer({
+			fn: () => this.options.mutationFn ? this.options.mutationFn(u, B) : Promise.reject(/* @__PURE__ */ Error("No mutationFn found")),
+			onFail: (u, z) => {
+				this.#i({
+					type: "failed",
+					failureCount: u,
+					error: z
+				});
+			},
+			onPause: () => {
+				this.#i({ type: "pause" });
+			},
+			onContinue: z,
+			retry: this.options.retry ?? 0,
+			retryDelay: this.options.retryDelay,
+			networkMode: this.options.networkMode,
+			canRun: () => this.#n.canRun(this)
+		});
+		let V = this.state.status === "pending", H = !this.#r.canStart();
+		try {
+			if (V) z();
+			else {
+				this.#i({
+					type: "pending",
+					variables: u,
+					isPaused: H
+				}), await this.#n.config.onMutate?.(u, this, B);
+				let z = await this.options.onMutate?.(u, B);
+				z !== this.state.context && this.#i({
+					type: "pending",
+					context: z,
+					variables: u,
+					isPaused: H
+				});
+			}
+			let U = await this.#r.start();
+			return await this.#n.config.onSuccess?.(U, u, this.state.context, this, B), await this.options.onSuccess?.(U, u, this.state.context, B), await this.#n.config.onSettled?.(U, null, this.state.variables, this.state.context, this, B), await this.options.onSettled?.(U, null, u, this.state.context, B), this.#i({
+				type: "success",
+				data: U
+			}), U;
+		} catch (z) {
+			try {
+				await this.#n.config.onError?.(z, u, this.state.context, this, B);
+			} catch (u) {
+				Promise.reject(u);
+			}
+			try {
+				await this.options.onError?.(z, u, this.state.context, B);
+			} catch (u) {
+				Promise.reject(u);
+			}
+			try {
+				await this.#n.config.onSettled?.(void 0, z, this.state.variables, this.state.context, this, B);
+			} catch (u) {
+				Promise.reject(u);
+			}
+			try {
+				await this.options.onSettled?.(void 0, z, u, this.state.context, B);
+			} catch (u) {
+				Promise.reject(u);
+			}
+			throw this.#i({
+				type: "error",
+				error: z
+			}), z;
+		} finally {
+			this.#n.runNext(this);
+		}
+	}
+	#i(u) {
+		this.state = ((z) => {
+			switch (u.type) {
+				case "failed": return {
+					...z,
+					failureCount: u.failureCount,
+					failureReason: u.error
+				};
+				case "pause": return {
+					...z,
+					isPaused: !0
+				};
+				case "continue": return {
+					...z,
+					isPaused: !1
+				};
+				case "pending": return {
+					...z,
+					context: u.context,
+					data: void 0,
+					failureCount: 0,
+					failureReason: null,
+					error: null,
+					isPaused: u.isPaused,
+					status: "pending",
+					variables: u.variables,
+					submittedAt: Date.now()
+				};
+				case "success": return {
+					...z,
+					data: u.data,
+					failureCount: 0,
+					failureReason: null,
+					error: null,
+					status: "success",
+					isPaused: !1
+				};
+				case "error": return {
+					...z,
+					data: void 0,
+					error: u.error,
+					failureCount: z.failureCount + 1,
+					failureReason: u.error,
+					isPaused: !1,
+					status: "error"
+				};
+			}
+		})(this.state), notifyManager.batch(() => {
+			this.#t.forEach((z) => {
+				z.onMutationUpdate(u);
+			}), this.#n.notify({
+				mutation: this,
+				type: "updated",
+				action: u
+			});
+		});
+	}
+};
+function getDefaultState() {
+	return {
+		context: void 0,
+		data: void 0,
+		error: null,
+		failureCount: 0,
+		failureReason: null,
+		isPaused: !1,
+		status: "idle",
+		variables: void 0,
+		submittedAt: 0
+	};
+}
+var MutationCache = class extends Subscribable {
+	constructor(u = {}) {
+		super(), this.config = u, this.#e = /* @__PURE__ */ new Set(), this.#t = /* @__PURE__ */ new Map(), this.#n = 0;
+	}
+	#e;
+	#t;
+	#n;
+	build(u, z, B) {
+		let V = new Mutation({
+			client: u,
+			mutationCache: this,
+			mutationId: ++this.#n,
+			options: u.defaultMutationOptions(z),
+			state: B
+		});
+		return this.add(V), V;
+	}
+	add(u) {
+		this.#e.add(u);
+		let z = scopeFor(u);
+		if (typeof z == "string") {
+			let B = this.#t.get(z);
+			B ? B.push(u) : this.#t.set(z, [u]);
+		}
+		this.notify({
+			type: "added",
+			mutation: u
+		});
+	}
+	remove(u) {
+		if (this.#e.delete(u)) {
+			let z = scopeFor(u);
+			if (typeof z == "string") {
+				let B = this.#t.get(z);
+				if (B) if (B.length > 1) {
+					let z = B.indexOf(u);
+					z !== -1 && B.splice(z, 1);
+				} else B[0] === u && this.#t.delete(z);
+			}
+		}
+		this.notify({
+			type: "removed",
+			mutation: u
+		});
+	}
+	canRun(u) {
+		let z = scopeFor(u);
+		if (typeof z == "string") {
+			let B = this.#t.get(z)?.find((u) => u.state.status === "pending");
+			return !B || B === u;
+		} else return !0;
+	}
+	runNext(u) {
+		let z = scopeFor(u);
+		return typeof z == "string" ? (this.#t.get(z)?.find((z) => z !== u && z.state.isPaused))?.continue() ?? Promise.resolve() : Promise.resolve();
+	}
+	clear() {
+		notifyManager.batch(() => {
+			this.#e.forEach((u) => {
+				this.notify({
+					type: "removed",
+					mutation: u
+				});
+			}), this.#e.clear(), this.#t.clear();
+		});
+	}
+	getAll() {
+		return Array.from(this.#e);
+	}
+	find(u) {
+		let z = {
+			exact: !0,
+			...u
+		};
+		return this.getAll().find((u) => matchMutation(z, u));
+	}
+	findAll(u = {}) {
+		return this.getAll().filter((z) => matchMutation(u, z));
+	}
+	notify(u) {
+		notifyManager.batch(() => {
+			this.listeners.forEach((z) => {
+				z(u);
+			});
+		});
+	}
+	resumePausedMutations() {
+		let u = this.getAll().filter((u) => u.state.isPaused);
+		return notifyManager.batch(() => Promise.all(u.map((u) => u.continue().catch(noop))));
+	}
+};
+function scopeFor(u) {
+	return u.options.scope?.id;
+}
+var QueryCache = class extends Subscribable {
+	constructor(u = {}) {
+		super(), this.config = u, this.#e = /* @__PURE__ */ new Map();
+	}
+	#e;
+	build(u, z, B) {
+		let V = z.queryKey, H = z.queryHash ?? hashQueryKeyByOptions(V, z), U = this.get(H);
+		return U || (U = new Query({
+			client: u,
+			queryKey: V,
+			queryHash: H,
+			options: u.defaultQueryOptions(z),
+			state: B,
+			defaultOptions: u.getQueryDefaults(V)
+		}), this.add(U)), U;
+	}
+	add(u) {
+		this.#e.has(u.queryHash) || (this.#e.set(u.queryHash, u), this.notify({
+			type: "added",
+			query: u
+		}));
+	}
+	remove(u) {
+		let z = this.#e.get(u.queryHash);
+		z && (u.destroy(), z === u && this.#e.delete(u.queryHash), this.notify({
+			type: "removed",
+			query: u
+		}));
+	}
+	clear() {
+		notifyManager.batch(() => {
+			this.getAll().forEach((u) => {
+				this.remove(u);
+			});
+		});
+	}
+	get(u) {
+		return this.#e.get(u);
+	}
+	getAll() {
+		return [...this.#e.values()];
+	}
+	find(u) {
+		let z = {
+			exact: !0,
+			...u
+		};
+		return this.getAll().find((u) => matchQuery(z, u));
+	}
+	findAll(u = {}) {
+		let z = this.getAll();
+		return Object.keys(u).length > 0 ? z.filter((z) => matchQuery(u, z)) : z;
+	}
+	notify(u) {
+		notifyManager.batch(() => {
+			this.listeners.forEach((z) => {
+				z(u);
+			});
+		});
+	}
+	onFocus() {
+		notifyManager.batch(() => {
+			this.getAll().forEach((u) => {
+				u.onFocus();
+			});
+		});
+	}
+	onOnline() {
+		notifyManager.batch(() => {
+			this.getAll().forEach((u) => {
+				u.onOnline();
+			});
+		});
+	}
+}, QueryClient = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a;
+	#o;
+	#s;
+	constructor(u = {}) {
+		this.#e = u.queryCache || new QueryCache(), this.#t = u.mutationCache || new MutationCache(), this.#n = u.defaultOptions || {}, this.#r = /* @__PURE__ */ new Map(), this.#i = /* @__PURE__ */ new Map(), this.#a = 0;
+	}
+	mount() {
+		this.#a++, this.#a === 1 && (this.#o = focusManager.subscribe(async (u) => {
+			u && (await this.resumePausedMutations(), this.#e.onFocus());
+		}), this.#s = onlineManager.subscribe(async (u) => {
+			u && (await this.resumePausedMutations(), this.#e.onOnline());
+		}));
+	}
+	unmount() {
+		this.#a--, this.#a === 0 && (this.#o?.(), this.#o = void 0, this.#s?.(), this.#s = void 0);
+	}
+	isFetching(u) {
+		return this.#e.findAll({
+			...u,
+			fetchStatus: "fetching"
+		}).length;
+	}
+	isMutating(u) {
+		return this.#t.findAll({
+			...u,
+			status: "pending"
+		}).length;
+	}
+	getQueryData(u) {
+		let z = this.defaultQueryOptions({ queryKey: u });
+		return this.#e.get(z.queryHash)?.state.data;
+	}
+	ensureQueryData(u) {
+		let z = this.defaultQueryOptions(u), B = this.#e.build(this, z), V = B.state.data;
+		return V === void 0 ? this.fetchQuery(u) : (u.revalidateIfStale && B.isStaleByTime(resolveStaleTime(z.staleTime, B)) && this.prefetchQuery(z), Promise.resolve(V));
+	}
+	getQueriesData(u) {
+		return this.#e.findAll(u).map(({ queryKey: u, state: z }) => [u, z.data]);
+	}
+	setQueryData(u, z, B) {
+		let V = this.defaultQueryOptions({ queryKey: u }), H = this.#e.get(V.queryHash)?.state.data, U = functionalUpdate(z, H);
+		if (U !== void 0) return this.#e.build(this, V).setData(U, {
+			...B,
+			manual: !0
+		});
+	}
+	setQueriesData(u, z, B) {
+		return notifyManager.batch(() => this.#e.findAll(u).map(({ queryKey: u }) => [u, this.setQueryData(u, z, B)]));
+	}
+	getQueryState(u) {
+		let z = this.defaultQueryOptions({ queryKey: u });
+		return this.#e.get(z.queryHash)?.state;
+	}
+	removeQueries(u) {
+		let z = this.#e;
+		notifyManager.batch(() => {
+			z.findAll(u).forEach((u) => {
+				z.remove(u);
+			});
+		});
+	}
+	resetQueries(u, z) {
+		let B = this.#e;
+		return notifyManager.batch(() => (B.findAll(u).forEach((u) => {
+			u.reset();
+		}), this.refetchQueries({
+			type: "active",
+			...u
+		}, z)));
+	}
+	cancelQueries(u, z = {}) {
+		let B = {
+			revert: !0,
+			...z
+		}, V = notifyManager.batch(() => this.#e.findAll(u).map((u) => u.cancel(B)));
+		return Promise.all(V).then(noop).catch(noop);
+	}
+	invalidateQueries(u, z = {}) {
+		return notifyManager.batch(() => (this.#e.findAll(u).forEach((u) => {
+			u.invalidate();
+		}), u?.refetchType === "none" ? Promise.resolve() : this.refetchQueries({
+			...u,
+			type: u?.refetchType ?? u?.type ?? "active"
+		}, z)));
+	}
+	refetchQueries(u, z = {}) {
+		let B = {
+			...z,
+			cancelRefetch: z.cancelRefetch ?? !0
+		}, V = notifyManager.batch(() => this.#e.findAll(u).filter((u) => !u.isDisabled() && !u.isStatic()).map((u) => {
+			let z = u.fetch(void 0, B);
+			return B.throwOnError || (z = z.catch(noop)), u.state.fetchStatus === "paused" ? Promise.resolve() : z;
+		}));
+		return Promise.all(V).then(noop);
+	}
+	fetchQuery(u) {
+		let z = this.defaultQueryOptions(u);
+		z.retry === void 0 && (z.retry = !1);
+		let B = this.#e.build(this, z);
+		return B.isStaleByTime(resolveStaleTime(z.staleTime, B)) ? B.fetch(z) : Promise.resolve(B.state.data);
+	}
+	prefetchQuery(u) {
+		return this.fetchQuery(u).then(noop).catch(noop);
+	}
+	fetchInfiniteQuery(u) {
+		return u.behavior = infiniteQueryBehavior(u.pages), this.fetchQuery(u);
+	}
+	prefetchInfiniteQuery(u) {
+		return this.fetchInfiniteQuery(u).then(noop).catch(noop);
+	}
+	ensureInfiniteQueryData(u) {
+		return u.behavior = infiniteQueryBehavior(u.pages), this.ensureQueryData(u);
+	}
+	resumePausedMutations() {
+		return onlineManager.isOnline() ? this.#t.resumePausedMutations() : Promise.resolve();
+	}
+	getQueryCache() {
+		return this.#e;
+	}
+	getMutationCache() {
+		return this.#t;
+	}
+	getDefaultOptions() {
+		return this.#n;
+	}
+	setDefaultOptions(u) {
+		this.#n = u;
+	}
+	setQueryDefaults(u, z) {
+		this.#r.set(hashKey(u), {
+			queryKey: u,
+			defaultOptions: z
+		});
+	}
+	getQueryDefaults(u) {
+		let z = [...this.#r.values()], B = {};
+		return z.forEach((z) => {
+			partialMatchKey(u, z.queryKey) && Object.assign(B, z.defaultOptions);
+		}), B;
+	}
+	setMutationDefaults(u, z) {
+		this.#i.set(hashKey(u), {
+			mutationKey: u,
+			defaultOptions: z
+		});
+	}
+	getMutationDefaults(u) {
+		let z = [...this.#i.values()], B = {};
+		return z.forEach((z) => {
+			partialMatchKey(u, z.mutationKey) && Object.assign(B, z.defaultOptions);
+		}), B;
+	}
+	defaultQueryOptions(u) {
+		if (u._defaulted) return u;
+		let z = {
+			...this.#n.queries,
+			...this.getQueryDefaults(u.queryKey),
+			...u,
+			_defaulted: !0
+		};
+		return z.queryHash ||= hashQueryKeyByOptions(z.queryKey, z), z.refetchOnReconnect === void 0 && (z.refetchOnReconnect = z.networkMode !== "always"), z.throwOnError === void 0 && (z.throwOnError = !!z.suspense), !z.networkMode && z.persister && (z.networkMode = "offlineFirst"), z.queryFn === skipToken && (z.enabled = !1), z;
+	}
+	defaultMutationOptions(u) {
+		return u?._defaulted ? u : {
+			...this.#n.mutations,
+			...u?.mutationKey && this.getMutationDefaults(u.mutationKey),
+			...u,
+			_defaulted: !0
+		};
+	}
+	clear() {
+		this.#e.clear(), this.#t.clear();
+	}
+};
+const dataBroker = class B {
+	constructor(u = {}) {
+		this.availableDatasets = [], this.apiUrl = u.apiUrl || "https://api.luzmo.com", this.apiVersion = u.apiVersion || "0.1.0", this.authKey = u.authKey || "", this.authToken = u.authToken || "", this.queryClient = new QueryClient({ defaultOptions: { queries: {
+			staleTime: u.staleTime || 300 * 1e3,
+			gcTime: u.gcTime || 600 * 1e3,
+			retry: u.retry || 3,
+			retryDelay: u.retryDelay || ((u) => Math.min(1e3 * 2 ** u, 3e4))
+		} } }), this.initNetworkListeners();
+	}
+	configure(u = {}) {
+		let z = u.authKey !== void 0 && u.authKey !== "" && u.authKey !== this.authKey || u.authToken !== void 0 && u.authToken !== "" && u.authToken !== this.authToken || u.apiUrl !== void 0 && u.apiUrl !== this.apiUrl;
+		if (u.apiVersion && (this.apiVersion = u.apiVersion), u.apiUrl !== void 0 && (this.apiUrl = u.apiUrl), u.authKey !== void 0 && (this.authKey = u.authKey), u.authToken !== void 0 && (this.authToken = u.authToken), z && (this.queryClient.clear(), this.availableDatasets = []), u.staleTime || u.gcTime || u.retry) {
+			let z = {};
+			u.staleTime && (z.staleTime = u.staleTime), u.gcTime && (z.gcTime = u.gcTime), u.retry && (z.retry = u.retry), this.queryClient.setDefaultOptions({ queries: {
+				...this.queryClient.getDefaultOptions().queries,
+				...z
+			} });
+		}
+	}
+	clearLocalCache() {
+		this.queryClient.clear(), this.availableDatasets = [];
+	}
+	initNetworkListeners() {
+		typeof window < "u" && window.addEventListener("online", () => {
+			console.warn("Network connection restored, refreshing data..."), this.refreshAll();
+		});
+	}
+	getHeaders(u = {}) {
+		return {
+			"Content-Type": "application/json",
+			...u
+		};
+	}
+	async fetchApi(u, z, B = {}) {
+		let V = `${this.apiUrl}/${this.apiVersion}${u}`, H = {
+			method: B.method || "POST",
+			headers: this.getHeaders(B.headers),
+			mode: "cors",
+			...B
+		};
+		z !== void 0 && (z.key = this.authKey, z.token = this.authToken, H.body = JSON.stringify(z));
+		try {
+			let z = await fetch(V, H);
+			if (!z.ok) {
+				let B = await z.json().catch(() => null);
+				throw z.status === 401 || z.status === 403 ? Error("Authentication failed. Please check your API token.") : z.status === 404 ? Error(`Resource not found: ${u}`) : z.status === 429 ? Error("Rate limit exceeded. Please try again later.") : Error(B?.message || `API request failed with status ${z.status}`);
+			}
+			return await z.json();
+		} catch (z) {
+			throw console.error(`API request to ${u} failed:`, z), z instanceof Error && (z.endpoint = u, z.timestamp = (/* @__PURE__ */ new Date()).toISOString()), z;
+		}
+	}
+	async fetchAllDatasets(u = {}) {
+		let z = u.offset || 0, B = u.limit || 50, V = [
+			"datasets",
+			z,
+			B
+		];
+		return await this.queryClient.fetchQuery({
+			queryKey: V,
+			queryFn: async () => {
+				let u = {
+					action: "get",
+					version: this.apiVersion,
+					find: {
+						where: { type: "dataset" },
+						attributes: [
+							"id",
+							"name",
+							"description"
+						],
+						limit: B,
+						offset: z
+					}
+				}, V = await this.fetchApi("/securable", u);
+				return {
+					data: V?.rows ?? [],
+					pagination: {
+						offset: z,
+						limit: B,
+						total: V?.count ?? 0,
+						pages: Math.ceil((V?.count ?? 0) / B)
+					}
+				};
+			}
+		});
+	}
+	async searchDatasets(u, z) {
+		if (!u) return { data: [] };
+		let B = [
+			"datasets",
+			"search",
+			u,
+			z
+		];
+		return await this.queryClient.fetchQuery({
+			queryKey: B,
+			queryFn: async () => {
+				let B = {
+					action: "get",
+					version: this.apiVersion,
+					find: { where: { type: "dataset" } }
+				};
+				u?.length > 0 && (B.find.search = {
+					match_types: ["name"],
+					keyphrase: u
+				}), z?.offset && (B.find.offset = z?.offset), z?.limit && (B.find.limit = z?.limit);
+				let V = await this.fetchApi("/securable", B), H = { data: V?.rows ?? [] };
+				return z?.limit && (H.pagination = {
+					offset: z?.offset ?? 0,
+					limit: z?.limit,
+					total: V?.count ?? 0,
+					pages: Math.ceil((V?.count ?? 0) / z?.limit)
+				}), H;
+			}
+		});
+	}
+	async fetchDatasetNames(z) {
+		if (!z || z.length === 0) throw Error("At least one dataset ID is required");
+		let { valid: B, invalid: V } = validateUuids(z);
+		if (V.length > 0 && console.warn(`[DataBroker] Invalid dataset IDs provided (not valid UUIDs): ${V.join(", ")}. These will be skipped.`), B.length === 0) throw Error("No valid dataset IDs provided. Dataset IDs must be valid UUIDs.");
+		let H = [
+			"dataset-names",
+			B,
+			this.authKey,
+			this.authToken
+		];
+		return await this.queryClient.fetchQuery({
+			queryKey: H,
+			queryFn: async () => {
+				let u = {
+					action: "get",
+					version: this.apiVersion,
+					find: {
+						where: {
+							type: "dataset",
+							id: { in: B }
+						},
+						attributes: [
+							"name",
+							"id",
+							"description"
+						]
+					}
+				};
+				return (await this.fetchApi("/securable", u))?.rows ?? [];
+			}
+		});
+	}
+	async fetchDatasetsWithColumnsAndFormulas(z) {
+		if (!z || z.length === 0) throw Error("At least one dataset ID is required");
+		let { valid: B, invalid: V } = validateUuids(z);
+		if (V.length > 0 && console.warn(`[DataBroker] Invalid dataset IDs provided (not valid UUIDs): ${V.join(", ")}. These will be skipped.`), B.length === 0) throw Error("No valid dataset IDs provided. Dataset IDs must be valid UUIDs.");
+		let H = [
+			"datasets",
+			B,
+			this.authKey,
+			this.authToken
+		];
+		return await this.queryClient.fetchQuery({
+			queryKey: H,
+			queryFn: async () => {
+				let u = {
+					action: "get",
+					version: this.apiVersion,
+					find: {
+						where: {
+							type: "dataset",
+							id: { in: B }
+						},
+						attributes: [
+							"name",
+							"id",
+							"description"
+						],
+						include: [{
+							model: "Column",
+							attributes: [
+								"id",
+								"name",
+								"description",
+								"type",
+								"subtype",
+								"format",
+								"hidden",
+								"lowestLevel",
+								"expression",
+								"duration_levels",
+								"duration_format"
+							],
+							separate: !0,
+							order: [["order", "asc"]],
+							include: [
+								{
+									model: "Column",
+									attributes: [
+										"id",
+										"securable_id",
+										"hierarchy_enabled",
+										"currency_id"
+									],
+									as: "Joins"
+								},
+								{
+									model: "HierarchyLevel",
+									attributes: [
+										"id",
+										"level",
+										"name"
+									],
+									as: "HierarchyLevels"
+								},
+								{
+									model: "Currency",
+									attributes: [
+										"id",
+										"name",
+										"symbol"
+									],
+									as: "Currency"
+								}
+							]
+						}, {
+							model: "Formula",
+							attributes: [
+								"id",
+								"name",
+								"description",
+								"type",
+								"subtype",
+								"format",
+								"hidden",
+								"lowestLevel",
+								"expression",
+								"duration_levels",
+								"duration_format"
+							],
+							include: [{
+								model: "Currency",
+								attributes: [
+									"id",
+									"name",
+									"symbol"
+								],
+								as: "Currency"
+							}]
+						}]
+					}
+				};
+				return (await this.fetchApi("/securable", u))?.rows ?? [];
+			}
+		});
+	}
+	async fetchData(u) {
+		if (!u) throw Error("Query is required");
+		let z = ["data", u];
+		return await this.queryClient.fetchQuery({
+			queryKey: z,
+			queryFn: async () => {
+				let z = {
+					action: "get",
+					version: this.apiVersion,
+					find: { queries: [u] }
+				}, B = await this.fetchApi("/data", z);
+				return {
+					data: B?.data || [],
+					performance: B?.performance || {}
+				};
+			}
+		});
+	}
+	async fetchTheme(u) {
+		if (!u) throw Error("Theme ID is required");
+		let z = ["theme", u];
+		return await this.queryClient.fetchQuery({
+			queryKey: z,
+			queryFn: async () => (await this.fetchApi("/theme", {
+				action: "get",
+				version: this.apiVersion,
+				find: { where: { id: u } }
+			}))?.rows?.[0]
+		});
+	}
+	refreshAll() {
+		this.queryClient.refetchQueries();
+	}
+	invalidateDatasetData(u) {
+		u ? (this.queryClient.invalidateQueries({ queryKey: ["dataset", u] }), this.queryClient.invalidateQueries({ queryKey: ["columns", u] })) : this.queryClient.invalidateQueries({ queryKey: ["datasets"] });
+	}
+	invalidateAll() {
+		this.queryClient.clear();
+	}
+	static getInstance(u = {}) {
+		return B.instance ? Object.keys(u).length > 0 && B.instance.configure(u) : B.instance = new B(u), B.instance;
+	}
+	async fetchDatasetsRecursive(B) {
+		if (!B || B.length === 0) throw Error("At least one dataset ID is required");
+		let { valid: V, invalid: H } = validateUuids(B);
+		if (H.length > 0 && console.warn(`[DataBroker] Invalid dataset IDs provided (not valid UUIDs): ${H.join(", ")}. These will be skipped.`), V.length === 0) throw Error("No valid dataset IDs provided. Dataset IDs must be valid UUIDs.");
+		let U = [...new Set(V)], W = /* @__PURE__ */ new Set(), G = /* @__PURE__ */ new Map(), K = (u) => {
+			u && isValidUuid(u) && !W.has(u) && !U.includes(u) && U.push(u);
+		};
+		for (; U.length > 0;) {
+			let u = [];
+			for (; U.length > 0 && u.length < 50;) {
+				let z = U.shift();
+				W.has(z) || u.push(z);
+			}
+			if (u.length !== 0) try {
+				(await this.fetchDatasetsWithColumnsAndFormulas(u)).forEach((u) => {
+					let z = this.postProcessDatasetMetadata(u);
+					W.add(z.id), this.queryClient.setQueryData(["dataset", z.id], z), (z.outgoingJoins ?? []).map((u) => u.securable_id).filter((u) => !!u && u !== z.id).forEach((u) => {
+						K(u);
+					}), G.set(z.id, z), this.availableDatasets.some((u) => u.id === z.id) || this.availableDatasets.push({
+						id: z.id,
+						name: z.name,
+						columns: z.columns
+					});
+				});
+			} catch (u) {
+				console.error("Error fetching datasets recursively:", u);
+			}
+		}
+		return [...G.values()];
+	}
+	postProcessDatasetMetadata(u) {
+		let z = [], B = (u.columns ?? []).map((u) => {
+			let B = u.joins ?? (Array.isArray(u.joins) ? u.joins : []);
+			Array.isArray(B) && B.length > 0 && z.push(...B);
+			let { joins: V, ...H } = u;
+			return {
+				...H,
+				joins: B
+			};
+		});
+		return {
+			...u,
+			columns: B,
+			formulas: u.formulas ?? [],
+			outgoingJoins: z,
+			dateLoaded: /* @__PURE__ */ new Date()
+		};
+	}
+	getAvailableDatasets() {
+		return this.availableDatasets;
+	}
+	getLinkedDatasetsIds(u) {
+		let z = this.queryClient.getQueryData(["dataset", u]);
+		return z ? (z.outgoingJoins ?? []).map((u) => u.securable_id).filter((z) => !!z && z !== u) : [];
+	}
+}.getInstance();
+export { dataBroker as t };