@latlng/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1455 @@
+//#region src/errors/index.ts
+var e = class extends Error {
+	cause;
+	constructor(e, t) {
+		super(e), this.name = new.target.name, this.cause = t?.cause;
+	}
+}, t = class extends e {
+	timeoutMs;
+	constructor(e, t) {
+		super(`request timed out after ${e}ms`, t), this.timeoutMs = e;
+	}
+}, n = class extends e {
+	status;
+	url;
+	body;
+	constructor(e, t) {
+		super(e, t), this.status = t.status, this.url = t.url, this.body = t.body;
+	}
+}, r = class extends n {}, i = class extends n {};
+//#endregion
+//#region src/http/routes.ts
+function a(e, t) {
+	return `${e.endsWith("/") ? e.slice(0, -1) : e}${t}`;
+}
+function o(e) {
+	let t = new URLSearchParams();
+	for (let [n, r] of Object.entries(e)) r != null && t.set(n, String(r));
+	let n = t.toString();
+	return n ? `?${n}` : "";
+}
+var s = {
+	ping: () => "/ping",
+	healthz: () => "/healthz",
+	server: () => "/server",
+	info: (e) => `/info${o({ section: e })}`,
+	metrics: () => "/metrics",
+	collections: (e) => `/collections${o({ match_pattern: e })}`,
+	collection: (e) => `/collections/${encodeURIComponent(e)}`,
+	renameCollection: (e) => `/collections/${encodeURIComponent(e)}/rename`,
+	bounds: (e) => `/collections/${encodeURIComponent(e)}/bounds`,
+	stats: (e) => `/collections/${encodeURIComponent(e)}/stats`,
+	object: (e, t) => `/collections/${encodeURIComponent(e)}/objects/${encodeURIComponent(t)}`,
+	objects: (e, t) => `/collections/${encodeURIComponent(e)}/objects${o({ match_pattern: t })}`,
+	fields: (e, t) => `/collections/${encodeURIComponent(e)}/objects/${encodeURIComponent(t)}/fields`,
+	field: (e, t, n) => `/collections/${encodeURIComponent(e)}/objects/${encodeURIComponent(t)}/fields/${encodeURIComponent(n)}`,
+	expire: (e, t) => `/collections/${encodeURIComponent(e)}/objects/${encodeURIComponent(t)}/expire`,
+	ttl: (e, t) => `/collections/${encodeURIComponent(e)}/objects/${encodeURIComponent(t)}/ttl`,
+	jsonRoot: (e, t) => `/collections/${encodeURIComponent(e)}/objects/${encodeURIComponent(t)}/json`,
+	jsonPath: (e, t, n) => `/collections/${encodeURIComponent(e)}/objects/${encodeURIComponent(t)}/json/${n}`,
+	nearby: (e) => `/collections/${encodeURIComponent(e)}/search/nearby`,
+	within: (e) => `/collections/${encodeURIComponent(e)}/search/within`,
+	intersects: (e) => `/collections/${encodeURIComponent(e)}/search/intersects`,
+	scan: (e) => `/collections/${encodeURIComponent(e)}/search/scan`,
+	search: (e) => `/collections/${encodeURIComponent(e)}/search/text`,
+	channels: (e) => `/channels${o({ match_pattern: e })}`,
+	channel: (e) => `/channels/${encodeURIComponent(e)}`,
+	hooks: (e) => `/hooks${o({ match_pattern: e })}`,
+	hook: (e) => `/hooks/${encodeURIComponent(e)}`,
+	config: (e) => `/config/${encodeURIComponent(e)}`,
+	flushdb: () => "/admin/flushdb",
+	gc: () => "/admin/gc",
+	aofshrink: () => "/admin/aofshrink",
+	webhookQueue: () => "/admin/webhook-queue",
+	configRewrite: () => "/admin/config/rewrite",
+	readonly: () => "/admin/readonly",
+	timeout: () => "/admin/timeout",
+	ws: () => "/ws"
+};
+//#endregion
+//#region src/auth/token.ts
+function c(e, t) {
+	t && e.set("authorization", `Bearer ${t}`);
+}
+//#endregion
+//#region src/internal/json.ts
+async function l(e) {
+	if (e.status === 204) return;
+	let t = await e.text();
+	if (t) try {
+		return JSON.parse(t);
+	} catch {
+		return t;
+	}
+}
+//#endregion
+//#region src/http/transport.ts
+var u = class {
+	baseUrl;
+	token;
+	timeoutMs;
+	headers;
+	fetchImpl;
+	constructor(e) {
+		this.baseUrl = e.baseUrl, this.token = e.token, this.timeoutMs = e.timeoutMs ?? 5e3, this.headers = e.headers, this.fetchImpl = e.fetch ?? globalThis.fetch.bind(globalThis);
+	}
+	async request(e) {
+		let r = a(e.baseUrl ?? this.baseUrl, e.path), i = new AbortController(), o = setTimeout(() => i.abort(), this.timeoutMs), s = new Headers(this.headers);
+		e.body !== void 0 && s.set("content-type", "application/json"), c(s, this.token);
+		try {
+			let t = await this.fetchImpl(r, {
+				method: e.method ?? "GET",
+				headers: s,
+				body: e.body === void 0 ? void 0 : JSON.stringify(e.body),
+				signal: i.signal
+			}), n = await l(t);
+			if (!t.ok) throw this.toHttpError(r, t.status, n);
+			return e.parser ? e.parser(n) : n;
+		} catch (e) {
+			throw e instanceof n ? e : e instanceof DOMException && e.name === "AbortError" ? new t(this.timeoutMs, { cause: e }) : e;
+		} finally {
+			clearTimeout(o);
+		}
+	}
+	async requestText(e) {
+		let r = a(e.baseUrl ?? this.baseUrl, e.path), i = new AbortController(), o = setTimeout(() => i.abort(), this.timeoutMs), s = new Headers(this.headers);
+		e.body !== void 0 && s.set("content-type", "application/json"), c(s, this.token);
+		try {
+			let t = await this.fetchImpl(r, {
+				method: e.method ?? "GET",
+				headers: s,
+				body: e.body === void 0 ? void 0 : JSON.stringify(e.body),
+				signal: i.signal
+			}), n = await t.text();
+			if (!t.ok) throw this.toHttpError(r, t.status, n);
+			return n;
+		} catch (e) {
+			throw e instanceof n ? e : e instanceof DOMException && e.name === "AbortError" ? new t(this.timeoutMs, { cause: e }) : e;
+		} finally {
+			clearTimeout(o);
+		}
+	}
+	toHttpError(e, t, a) {
+		let o = a && typeof a == "object" && "error" in a && typeof a.error == "string" ? a.error : typeof a == "string" && a.length > 0 ? a : `request failed with status ${t}`, s = {
+			status: t,
+			url: e,
+			body: a
+		};
+		return t === 401 ? new r(o, s) : t === 503 ? new i(o, s) : new n(o, s);
+	}
+};
+//#endregion
+//#region src/internal/assert.ts
+function d(e, t) {
+	if (!e) throw Error(t);
+}
+function f(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+//#endregion
+//#region src/types/models.ts
+function p(e, t, n) {
+	return {
+		type: "point",
+		lat: e,
+		lon: t,
+		z: n
+	};
+}
+function ee(e) {
+	return {
+		type: "bounds",
+		bounds: e
+	};
+}
+function m(e) {
+	return {
+		type: "hash",
+		value: e
+	};
+}
+function h(e) {
+	return {
+		type: "geojson",
+		value: e
+	};
+}
+function g(e) {
+	return {
+		type: "string",
+		value: e
+	};
+}
+function _(e) {
+	return {
+		type: "number",
+		value: e
+	};
+}
+function te(e) {
+	return {
+		type: "text",
+		value: e
+	};
+}
+function ne(e) {
+	return {
+		type: "json",
+		value: e
+	};
+}
+function v(e) {
+	return Object.entries(e ?? {}).map(([e, t]) => ({
+		name: e,
+		value: t
+	}));
+}
+function re(e) {
+	switch (e.type) {
+		case "number": return {
+			type: "number",
+			value: e.value
+		};
+		case "text": return {
+			type: "text",
+			value: e.value
+		};
+		case "json": return {
+			type: "json",
+			value: e.value
+		};
+	}
+}
+function y(e) {
+	d(f(e), "field value must be an object");
+	let t = e.type, n = e.value;
+	if (d(typeof t == "string", "field value type must be a string"), t === "number") return d(typeof n == "number", "field number value must be a number"), {
+		type: t,
+		value: n
+	};
+	if (d(typeof n == "string", "field text/json value must be a string"), t === "text" || t === "json") return {
+		type: t,
+		value: n
+	};
+	throw Error(`unknown field value type: ${t}`);
+}
+function b(e) {
+	return e ? (Array.isArray(e) ? e : v(e)).map((e) => ({
+		name: e.name,
+		value: re(e.value)
+	})) : [];
+}
+function x(e) {
+	if (!f(e)) return {};
+	let t = e.values;
+	return f(t) ? Object.fromEntries(Object.entries(t).map(([e, t]) => [e, y(t)])) : {};
+}
+function S(e) {
+	switch (e.type) {
+		case "point": return { Point: {
+			lat: e.lat,
+			lon: e.lon,
+			z: e.z ?? null
+		} };
+		case "bounds": return { Bounds: e.bounds };
+		case "hash": return { Hash: e.value };
+		case "geojson": return { GeoJson: e.value };
+		case "string": return { String: e.value };
+	}
+}
+function C(e) {
+	if (d(f(e), "geo object must be an object"), "Point" in e) {
+		let t = e.Point;
+		return d(f(t), "Point payload must be an object"), d(typeof t.lat == "number", "point lat must be a number"), d(typeof t.lon == "number", "point lon must be a number"), {
+			type: "point",
+			lat: t.lat,
+			lon: t.lon,
+			z: typeof t.z == "number" || t.z === null ? t.z : void 0
+		};
+	}
+	if ("Bounds" in e) {
+		let t = e.Bounds;
+		return d(f(t), "Bounds payload must be an object"), {
+			type: "bounds",
+			bounds: {
+				min_lat: Number(t.min_lat),
+				min_lon: Number(t.min_lon),
+				max_lat: Number(t.max_lat),
+				max_lon: Number(t.max_lon)
+			}
+		};
+	}
+	if ("Hash" in e) return d(typeof e.Hash == "string", "Hash payload must be a string"), {
+		type: "hash",
+		value: e.Hash
+	};
+	if ("GeoJson" in e) return {
+		type: "geojson",
+		value: e.GeoJson
+	};
+	if ("String" in e) return d(typeof e.String == "string", "String payload must be a string"), {
+		type: "string",
+		value: e.String
+	};
+	throw Error("unknown geo object shape");
+}
+function w(e) {
+	switch (e.type) {
+		case "circle": return { Circle: {
+			lat: e.lat,
+			lon: e.lon,
+			meters: e.meters
+		} };
+		case "bounds": return { Bounds: e.bounds };
+		case "hash": return { Hash: e.value };
+		case "geojson": return { GeoJson: e.value };
+		case "tile": return { Tile: {
+			x: e.x,
+			y: e.y,
+			z: e.z
+		} };
+		case "quadkey": return { Quadkey: e.value };
+		case "sector": return { Sector: {
+			lat: e.lat,
+			lon: e.lon,
+			meters: e.meters,
+			bearing1: e.bearing1,
+			bearing2: e.bearing2
+		} };
+		case "reference": return { Reference: {
+			collection: e.collection,
+			id: e.id
+		} };
+	}
+}
+function T(e) {
+	if (d(f(e), "area must be an object"), "Circle" in e) {
+		let t = e.Circle;
+		return d(f(t), "Circle payload must be an object"), d(typeof t.lat == "number", "circle lat must be a number"), d(typeof t.lon == "number", "circle lon must be a number"), d(typeof t.meters == "number", "circle meters must be a number"), {
+			type: "circle",
+			lat: t.lat,
+			lon: t.lon,
+			meters: t.meters
+		};
+	}
+	if ("Bounds" in e) {
+		let t = e.Bounds;
+		return d(f(t), "Bounds payload must be an object"), {
+			type: "bounds",
+			bounds: {
+				min_lat: Number(t.min_lat),
+				min_lon: Number(t.min_lon),
+				max_lat: Number(t.max_lat),
+				max_lon: Number(t.max_lon)
+			}
+		};
+	}
+	if ("Hash" in e) return d(typeof e.Hash == "string", "Hash payload must be a string"), {
+		type: "hash",
+		value: e.Hash
+	};
+	if ("GeoJson" in e) return {
+		type: "geojson",
+		value: e.GeoJson
+	};
+	if ("Tile" in e) {
+		let t = e.Tile;
+		return d(f(t), "Tile payload must be an object"), d(typeof t.x == "number", "tile x must be a number"), d(typeof t.y == "number", "tile y must be a number"), d(typeof t.z == "number", "tile z must be a number"), {
+			type: "tile",
+			x: t.x,
+			y: t.y,
+			z: t.z
+		};
+	}
+	if ("Quadkey" in e) return d(typeof e.Quadkey == "string", "Quadkey payload must be a string"), {
+		type: "quadkey",
+		value: e.Quadkey
+	};
+	if ("Sector" in e) {
+		let t = e.Sector;
+		return d(f(t), "Sector payload must be an object"), d(typeof t.lat == "number", "sector lat must be a number"), d(typeof t.lon == "number", "sector lon must be a number"), d(typeof t.meters == "number", "sector meters must be a number"), d(typeof t.bearing1 == "number", "sector bearing1 must be a number"), d(typeof t.bearing2 == "number", "sector bearing2 must be a number"), {
+			type: "sector",
+			lat: t.lat,
+			lon: t.lon,
+			meters: t.meters,
+			bearing1: t.bearing1,
+			bearing2: t.bearing2
+		};
+	}
+	if ("Reference" in e) {
+		let t = e.Reference;
+		return d(f(t), "Reference payload must be an object"), d(typeof t.collection == "string", "reference collection must be a string"), d(typeof t.id == "string", "reference id must be a string"), {
+			type: "reference",
+			collection: t.collection,
+			id: t.id
+		};
+	}
+	throw Error("unknown area shape");
+}
+function E(e) {
+	return e === "desc" ? "Desc" : "Asc";
+}
+function ie(e) {
+	return !e || e === "objects" ? "Objects" : e === "points" ? "Points" : e === "bounds" ? "Bounds" : e === "ids" ? "Ids" : e === "count" ? "Count" : { Hashes: { precision: e.hashes.precision } };
+}
+function ae(e) {
+	switch (e.type) {
+		case "range": return { Range: {
+			min: e.min,
+			max: e.max
+		} };
+		case "equalsText": return { EqualsText: e.value };
+		case "regex": return { Regex: e.value };
+	}
+}
+function D(e) {
+	let t = e ?? {};
+	return {
+		cursor: t.cursor ?? 0,
+		limit: t.limit ?? 100,
+		nofields: t.nofields ?? !1,
+		match_pattern: t.matchPattern ?? null,
+		sort: E(t.sort),
+		where_filters: (t.whereFilters ?? []).map((e) => ({
+			field: e.field,
+			comparison: ae(e.comparison)
+		})),
+		where_in_filters: t.whereInFilters ?? [],
+		where_expr_filters: t.whereExprFilters ?? [],
+		clip: t.clip ?? !1,
+		output: ie(t.output)
+	};
+}
+function oe(e) {
+	return e == null ? null : (d(f(e), "object response must be an object"), d(typeof e.id == "string", "object id must be a string"), {
+		id: e.id,
+		geo: C(e.geo),
+		fields: x(e.fields),
+		expires_at: typeof e.expires_at == "number" ? e.expires_at : null
+	});
+}
+function O(e) {
+	return d(f(e), "search results must be an object"), d(Array.isArray(e.results), "search results array is missing"), {
+		results: e.results.map((e) => (d(f(e), "search result item must be an object"), d(typeof e.id == "string", "search result id must be a string"), {
+			id: e.id,
+			object: e.object === null || e.object === void 0 ? void 0 : C(e.object),
+			fields: e.fields === null || e.fields === void 0 ? void 0 : x(e.fields),
+			distance_meters: typeof e.distance_meters == "number" ? e.distance_meters : null
+		})),
+		cursor: Number(e.cursor ?? 0),
+		count: Number(e.count ?? 0)
+	};
+}
+function k(e) {
+	return d(f(e), "server info must be an object"), {
+		version: typeof e.version == "string" ? e.version : "",
+		api_version: typeof e.api_version == "string" ? e.api_version : "",
+		protocol_version: typeof e.protocol_version == "string" ? e.protocol_version : "",
+		storage_format_version: typeof e.storage_format_version == "string" ? e.storage_format_version : "",
+		num_collections: Number(e.num_collections ?? 0),
+		num_objects: Number(e.num_objects ?? 0),
+		num_points: Number(e.num_points ?? 0),
+		heap_bytes: Number(e.heap_bytes ?? 0),
+		read_only: !!e.read_only,
+		leader: !!e.leader,
+		server_id: typeof e.server_id == "string" ? e.server_id : "",
+		following: typeof e.following == "string" ? e.following : null,
+		caught_up: !!e.caught_up,
+		caught_up_once: !!e.caught_up_once,
+		last_sequence: Number(e.last_sequence ?? 0)
+	};
+}
+//#endregion
+//#region src/types/events.ts
+function A(e) {
+	switch (e) {
+		case "set": return "Set";
+		case "del": return "Del";
+		case "drop": return "Drop";
+		case "fset": return "Fset";
+	}
+}
+function j(e) {
+	switch (e) {
+		case "inside": return "Inside";
+		case "outside": return "Outside";
+		case "enter": return "Enter";
+		case "exit": return "Exit";
+		case "cross": return "Cross";
+		case "roam": return "Roam";
+	}
+}
+function M(e) {
+	switch (e) {
+		case "Set":
+		case "set": return "set";
+		case "Del":
+		case "del": return "del";
+		case "Drop":
+		case "drop": return "drop";
+		case "Fset":
+		case "fset": return "fset";
+		default: throw Error(`unknown mutation command: ${String(e)}`);
+	}
+}
+function N(e) {
+	switch (e) {
+		case "Inside":
+		case "inside": return "inside";
+		case "Outside":
+		case "outside": return "outside";
+		case "Enter":
+		case "enter": return "enter";
+		case "Exit":
+		case "exit": return "exit";
+		case "Cross":
+		case "cross": return "cross";
+		case "Roam":
+		case "roam": return "roam";
+		default: throw Error(`unknown detect type: ${String(e)}`);
+	}
+}
+function P(e) {
+	switch (e.type) {
+		case "nearby": return { Nearby: {
+			lat: e.lat,
+			lon: e.lon,
+			meters: e.meters,
+			options: D(e.options)
+		} };
+		case "within": return { Within: {
+			area: w(e.area),
+			options: D(e.options)
+		} };
+		case "intersects": return { Intersects: {
+			area: w(e.area),
+			options: D(e.options)
+		} };
+		case "roam": return { Roam: {
+			target_collection: e.targetCollection,
+			target_pattern: e.targetPattern,
+			meters: e.meters,
+			options: D(e.options),
+			nodwell: e.nodwell ?? !1
+		} };
+	}
+}
+function F(e) {
+	return {
+		collection: e.collection,
+		query: P(e.query),
+		detect: e.detect.map(j),
+		commands: e.commands.map(A)
+	};
+}
+function I(e) {
+	return d(Array.isArray(e), "hooks response must be an array"), e.map((e) => (d(f(e), "hook info must be an object"), d(typeof e.name == "string", "hook name must be a string"), d(typeof e.endpoint == "string", "hook endpoint must be a string"), d(typeof e.collection == "string", "hook collection must be a string"), {
+		name: e.name,
+		endpoint: e.endpoint,
+		collection: e.collection
+	}));
+}
+function L(e) {
+	return d(f(e), "channel definition must be an object"), d(typeof e.name == "string", "channel name must be a string"), {
+		name: e.name,
+		def: B(e.def)
+	};
+}
+function R(e) {
+	return d(f(e), "hook definition must be an object"), d(typeof e.name == "string", "hook name must be a string"), d(typeof e.endpoint == "string", "hook endpoint must be a string"), {
+		name: e.name,
+		endpoint: e.endpoint,
+		def: B(e.def)
+	};
+}
+function z(e) {
+	return d(f(e), "geofence event must be an object"), d(typeof e.collection == "string", "event collection missing"), d(typeof e.id == "string", "event id missing"), d(typeof e.timestamp_ns == "number", "timestamp missing"), {
+		command: M(e.command),
+		detect: N(e.detect),
+		collection: e.collection,
+		id: e.id,
+		object: C(e.object),
+		fields: x(e.fields),
+		timestamp_ns: e.timestamp_ns,
+		event_id: typeof e.event_id == "string" ? e.event_id : null,
+		job_id: typeof e.job_id == "string" ? e.job_id : null,
+		hook: typeof e.hook == "string" ? e.hook : null,
+		group: typeof e.group == "string" ? e.group : null,
+		nearby: f(e.nearby) && typeof e.nearby.collection == "string" && typeof e.nearby.id == "string" && typeof e.nearby.meters == "number" ? {
+			collection: e.nearby.collection,
+			id: e.nearby.id,
+			meters: e.nearby.meters
+		} : null
+	};
+}
+function B(e) {
+	return d(f(e), "geofence definition must be an object"), d(typeof e.collection == "string", "geofence collection must be a string"), d(Array.isArray(e.detect), "geofence detect must be an array"), d(Array.isArray(e.commands), "geofence commands must be an array"), {
+		collection: e.collection,
+		query: V(e.query),
+		detect: e.detect.map(N),
+		commands: e.commands.map(M)
+	};
+}
+function V(e) {
+	if (d(f(e), "geofence query must be an object"), "Nearby" in e) {
+		let t = e.Nearby;
+		return d(f(t), "Nearby payload must be an object"), d(typeof t.lat == "number", "nearby lat must be a number"), d(typeof t.lon == "number", "nearby lon must be a number"), d(typeof t.meters == "number", "nearby meters must be a number"), {
+			type: "nearby",
+			lat: t.lat,
+			lon: t.lon,
+			meters: t.meters,
+			options: H(t.options)
+		};
+	}
+	if ("Within" in e) {
+		let t = e.Within;
+		return d(f(t), "Within payload must be an object"), {
+			type: "within",
+			area: T(t.area),
+			options: H(t.options)
+		};
+	}
+	if ("Intersects" in e) {
+		let t = e.Intersects;
+		return d(f(t), "Intersects payload must be an object"), {
+			type: "intersects",
+			area: T(t.area),
+			options: H(t.options)
+		};
+	}
+	if ("Roam" in e) {
+		let t = e.Roam;
+		return d(f(t), "Roam payload must be an object"), d(typeof t.target_collection == "string", "roam target_collection must be a string"), d(typeof t.target_pattern == "string", "roam target_pattern must be a string"), d(typeof t.meters == "number", "roam meters must be a number"), {
+			type: "roam",
+			targetCollection: t.target_collection,
+			targetPattern: t.target_pattern,
+			meters: t.meters,
+			options: H(t.options),
+			nodwell: typeof t.nodwell == "boolean" ? t.nodwell : void 0
+		};
+	}
+	throw Error("unknown geofence query shape");
+}
+function H(e) {
+	if (!f(e)) return;
+	let t = typeof e.limit == "number" ? e.limit : void 0, n = typeof e.cursor == "number" ? e.cursor : void 0, r = typeof e.nofields == "boolean" ? e.nofields : void 0, i = typeof e.match_pattern == "string" ? e.match_pattern : void 0, a = typeof e.clip == "boolean" ? e.clip : void 0, o;
+	return e.sort === "Desc" ? o = "desc" : e.sort === "Asc" && (o = "asc"), {
+		cursor: n,
+		limit: t,
+		nofields: r,
+		matchPattern: i,
+		sort: o,
+		clip: a
+	};
+}
+//#endregion
+//#region src/internal/response-parsers.ts
+function U(t) {
+	if (t && typeof t == "object" && "collections" in t && Array.isArray(t.collections)) return t.collections.filter((e) => typeof e == "string");
+	throw new e("invalid collections response");
+}
+function W(t) {
+	if (t && typeof t == "object" && "channels" in t && Array.isArray(t.channels)) return t.channels.filter((e) => typeof e == "string");
+	throw new e("invalid channels response");
+}
+function G(t) {
+	if (!Array.isArray(t)) throw new e("invalid stats response");
+	return t;
+}
+function K(t) {
+	if (!t || typeof t != "object" || !("server" in t)) throw new e("invalid info response");
+	let n = t;
+	return {
+		server: k(n.server),
+		metrics: n.metrics && typeof n.metrics == "object" ? n.metrics : void 0,
+		section: typeof n.section == "string" ? n.section : void 0
+	};
+}
+function q(t) {
+	if (t && typeof t == "object" && "bounds" in t && t.bounds && typeof t.bounds == "object") return t.bounds;
+	throw new e("invalid bounds response");
+}
+function se(t) {
+	if (!t || typeof t != "object" || !("name" in t) || typeof t.name != "string" || !("stats" in t) || !t.stats || typeof t.stats != "object") throw new e("invalid collection info response");
+	return t;
+}
+function ce(t) {
+	if (!t || typeof t != "object") throw new e("invalid webhook queue response");
+	return t;
+}
+function le(t) {
+	if (!t || typeof t != "object") throw new e("invalid compaction response");
+	return t;
+}
+function J(t) {
+	if (!t || typeof t != "object" || !("deleted" in t)) throw new e("invalid delete response");
+	return !!t.deleted;
+}
+function ue(t) {
+	if (!t || typeof t != "object" || !("deleted" in t)) throw new e("invalid delete response");
+	return Number(t.deleted ?? 0);
+}
+function de(t) {
+	if (!t || typeof t != "object" || !("stored" in t)) throw new e("invalid set response");
+	return !!t.stored;
+}
+function fe(t) {
+	if (!t || typeof t != "object" || !("updated" in t)) throw new e("invalid update response");
+	return !!t.updated;
+}
+function pe(t) {
+	if (!t || typeof t != "object" || !("renamed" in t)) throw new e("invalid rename response");
+	return !!t.renamed;
+}
+function me(t) {
+	if (!t || typeof t != "object" || !("dropped" in t)) throw new e("invalid drop response");
+	return !!t.dropped;
+}
+function he(e) {
+	if (e === null) return null;
+	if (e && typeof e == "object" && "type" in e) return y(e);
+	if (e && typeof e == "object" && "value" in e) {
+		let t = e.value;
+		return t == null ? null : y(t);
+	}
+	return y(e);
+}
+function ge(t) {
+	if (!t || typeof t != "object" || !("ttl" in t)) throw new e("invalid ttl response");
+	let n = t.ttl;
+	return typeof n == "number" ? n : null;
+}
+function _e(e) {
+	if (e === null) return null;
+	let t = e && typeof e == "object" && "value" in e ? e.value : e;
+	if (t == null) return null;
+	if (typeof t != "string") return t;
+	try {
+		return JSON.parse(t);
+	} catch {
+		return t;
+	}
+}
+function Y(t, n) {
+	if (!t || typeof t != "object" || !(n in t)) throw new e(`invalid ${n} response`);
+	return !!t[n];
+}
+function ve(t) {
+	if (!t || typeof t != "object" || !("seconds" in t)) throw new e("invalid timeout response");
+	let n = t.seconds;
+	return typeof n == "number" ? n : null;
+}
+function ye(e) {
+	return L(e);
+}
+function X(e) {
+	return R(e);
+}
+function be(e) {
+	return I(e);
+}
+//#endregion
+//#region src/routing/read-preference.ts
+function xe(e, t, n) {
+	let r = e.filter((e) => e.eligible).map((e) => e.url);
+	if (r.length === 0) return [];
+	if (t === "roundRobinFollowers") {
+		let e = n % r.length;
+		return [...r.slice(e), ...r.slice(0, e)];
+	}
+	return r;
+}
+//#endregion
+//#region src/routing/replicas.ts
+var Se = class {
+	leaderUrl;
+	readReplicas;
+	readPreference;
+	statusTtlMs;
+	statusCache = /* @__PURE__ */ new Map();
+	roundRobinCursor = 0;
+	constructor(e) {
+		this.leaderUrl = e.leaderUrl, this.readReplicas = e.readReplicas ?? [], this.readPreference = e.readPreference ?? "leader", this.statusTtlMs = e.statusTtlMs ?? 1e3;
+	}
+	getLeaderUrl() {
+		return this.leaderUrl;
+	}
+	async getReadCandidates(e) {
+		let t = xe(await Promise.all(this.readReplicas.map(async (t) => ({
+			url: t,
+			eligible: await this.isEligibleReplica(t, e)
+		}))), this.readPreference, this.roundRobinCursor);
+		return this.readPreference === "roundRobinFollowers" && t.length > 0 && (this.roundRobinCursor += 1), t;
+	}
+	getReadPreference() {
+		return this.readPreference;
+	}
+	async isEligibleReplica(e, t) {
+		let n = Date.now(), r = this.statusCache.get(e);
+		if (r && r.expiresAt > n) return !!(r.info && !r.info.leader && r.info.caught_up_once);
+		try {
+			let r = await t.request({
+				baseUrl: e,
+				path: s.server(),
+				parser: k
+			});
+			return this.statusCache.set(e, {
+				expiresAt: n + this.statusTtlMs,
+				info: r
+			}), !r.leader && r.caught_up_once;
+		} catch {
+			return this.statusCache.set(e, { expiresAt: n + this.statusTtlMs }), !1;
+		}
+	}
+}, Ce = class {
+	values = [];
+	resolvers = [];
+	closed = !1;
+	push(e) {
+		if (this.closed) return;
+		let t = this.resolvers.shift();
+		if (t) {
+			t({
+				value: e,
+				done: !1
+			});
+			return;
+		}
+		this.values.push(e);
+	}
+	close() {
+		for (this.closed = !0; this.resolvers.length > 0;) this.resolvers.shift()?.({
+			value: void 0,
+			done: !0
+		});
+	}
+	next() {
+		let e = this.values.shift();
+		return e === void 0 ? this.closed ? Promise.resolve({
+			value: void 0,
+			done: !0
+		}) : new Promise((e) => {
+			this.resolvers.push(e);
+		}) : Promise.resolve({
+			value: e,
+			done: !1
+		});
+	}
+}, Z = class {
+	events = new Ce();
+	eventHandlers = /* @__PURE__ */ new Set();
+	closeHandlers = /* @__PURE__ */ new Set();
+	errorHandlers = /* @__PURE__ */ new Set();
+	closeFn;
+	closed = !1;
+	constructor(e) {
+		this.closeFn = e;
+	}
+	on(e, t) {
+		return e === "event" ? (this.eventHandlers.add(t), () => {
+			this.eventHandlers.delete(t);
+		}) : e === "close" ? (this.closeHandlers.add(t), () => {
+			this.closeHandlers.delete(t);
+		}) : (this.errorHandlers.add(t), () => {
+			this.errorHandlers.delete(t);
+		});
+	}
+	push(e) {
+		this.events.push(e);
+		for (let t of this.eventHandlers) t(e);
+	}
+	fail(e) {
+		for (let t of this.errorHandlers) t(e);
+	}
+	close() {
+		this.closed || (this.closed = !0, this.closeFn(), this.finish());
+	}
+	finish() {
+		this.closed ||= !0, this.events.close();
+		for (let e of this.closeHandlers) e();
+	}
+	[Symbol.asyncIterator]() {
+		return { next: () => this.events.next() };
+	}
+}, Q = class t {
+	socket;
+	token;
+	pending = [];
+	activeSubscription;
+	constructor(t, n) {
+		this.socket = t, this.token = n, this.socket.addEventListener("message", (e) => {
+			this.handleMessage(e);
+		}), this.socket.addEventListener("close", () => {
+			for (this.activeSubscription?.finish(), this.activeSubscription = void 0; this.pending.length > 0;) this.pending.shift()?.reject(new e("websocket closed before command acknowledgement"));
+		}), this.socket.addEventListener("error", () => {
+			this.activeSubscription?.fail(new e("websocket transport error"));
+		});
+	}
+	static async connect(n) {
+		let r = (n.webSocketFactory ?? ((t) => {
+			if (typeof WebSocket != "function") throw new e("global WebSocket is not available");
+			return new WebSocket(t);
+		}))(n.url);
+		await new Promise((t, n) => {
+			r.addEventListener("open", () => t(), { once: !0 }), r.addEventListener("error", () => n(new e("failed to open websocket")), { once: !0 });
+		});
+		let i = new t(r, n.token);
+		if (n.token) {
+			let t = await i.command({
+				type: "auth",
+				token: n.token
+			});
+			if (!t || typeof t != "object" || t.authorized !== !0) throw new e("websocket authentication failed");
+		}
+		return i;
+	}
+	async ping() {
+		return this.command({ type: "ping" });
+	}
+	async subscribe(e) {
+		let t = this.replaceSubscription();
+		try {
+			return await this.command({
+				type: "subscribe",
+				channels: e
+			}), t;
+		} catch (e) {
+			throw t.close(), e;
+		}
+	}
+	async psubscribe(e) {
+		let t = this.replaceSubscription();
+		try {
+			return await this.command({
+				type: "psubscribe",
+				patterns: e
+			}), t;
+		} catch (e) {
+			throw t.close(), e;
+		}
+	}
+	async quit() {
+		try {
+			await this.command({ type: "quit" });
+		} catch {} finally {
+			this.close();
+		}
+	}
+	close() {
+		this.socket.close();
+	}
+	replaceSubscription() {
+		this.activeSubscription?.close();
+		let e = new Z(() => {
+			this.close();
+		});
+		return this.activeSubscription = e, e;
+	}
+	async command(t) {
+		if (this.socket.readyState !== WebSocket.OPEN) throw new e("websocket is not open");
+		let n = new Promise((e, t) => {
+			this.pending.push({
+				resolve: e,
+				reject: t
+			});
+		});
+		return this.socket.send(JSON.stringify(t)), n;
+	}
+	handleMessage(t) {
+		let n = JSON.parse(t.data), r = this.tryParseEvent(n);
+		if (r) {
+			this.activeSubscription?.push(r);
+			return;
+		}
+		let i = this.pending.shift();
+		if (i) {
+			if (n && typeof n == "object" && "error" in n && typeof n.error == "string") {
+				i.reject(new e(n.error));
+				return;
+			}
+			i.resolve(n);
+		}
+	}
+	tryParseEvent(e) {
+		try {
+			return z(e);
+		} catch {
+			return null;
+		}
+	}
+};
+//#endregion
+//#region src/client.ts
+function we(e) {
+	switch (e) {
+		case "nx": return "Nx";
+		case "xx": return "Xx";
+		default: return "Always";
+	}
+}
+function Te(e) {
+	return !e || e === "objects" ? { format: "objects" } : e === "points" || e === "bounds" ? { format: e } : "hashes" in e ? {
+		format: "hashes",
+		hash_precision: e.hashes.precision
+	} : { format: "objects" };
+}
+var Ee = class {
+	transport;
+	replicaRouter;
+	token;
+	webSocketFactory;
+	constructor(e) {
+		this.transport = new u({
+			baseUrl: e.leaderUrl,
+			token: e.token,
+			timeoutMs: e.timeoutMs,
+			headers: e.headers,
+			fetch: e.fetch
+		}), this.replicaRouter = new Se({
+			leaderUrl: e.leaderUrl,
+			readReplicas: e.readReplicas,
+			readPreference: e.readPreference,
+			statusTtlMs: e.replicaStatusTtlMs
+		}), this.token = e.token, this.webSocketFactory = e.webSocketFactory;
+	}
+	async ping() {
+		return this.requestLeader({
+			path: s.ping(),
+			parser: (e) => e
+		});
+	}
+	async healthz() {
+		return this.requestLeader({
+			path: s.healthz(),
+			parser: (e) => e
+		});
+	}
+	async server() {
+		return this.requestLeader({
+			path: s.server(),
+			parser: k
+		});
+	}
+	async info(e) {
+		return this.requestLeader({
+			path: s.info(e),
+			parser: K
+		});
+	}
+	async metrics() {
+		return this.transport.requestText({ path: s.metrics() });
+	}
+	async collections(e) {
+		return this.requestRead({
+			path: s.collections(e),
+			parser: U
+		});
+	}
+	async createCollection(e) {
+		return this.requestWrite({
+			method: "POST",
+			path: s.collection(e),
+			parser: (e) => Y(e, "created")
+		});
+	}
+	async getCollection(e) {
+		try {
+			return await this.requestRead({
+				path: s.collection(e),
+				parser: se
+			});
+		} catch (e) {
+			if (e instanceof n && e.status === 404) return null;
+			throw e;
+		}
+	}
+	async rename(e, t, n) {
+		return this.requestWrite({
+			method: "POST",
+			path: s.renameCollection(e),
+			body: {
+				new_name: t,
+				nx: n?.nx ?? !1
+			},
+			parser: pe
+		});
+	}
+	async bounds(e) {
+		return this.requestRead({
+			path: s.bounds(e),
+			parser: q
+		});
+	}
+	async stats(e) {
+		return this.requestRead({
+			path: s.stats(e),
+			parser: G
+		});
+	}
+	async setObject(e, t, n, r) {
+		return this.requestWrite({
+			method: "POST",
+			path: s.object(e, t),
+			body: {
+				object: S(n),
+				fields: b(r?.fields),
+				expire_seconds: r?.expireSeconds,
+				condition: we(r?.condition)
+			},
+			parser: de
+		});
+	}
+	async setPoint(e, t, n, r) {
+		return this.setObject(e, t, p(n.lat, n.lon, n.z), r);
+	}
+	async get(e, t, n) {
+		let r = Te(n?.format);
+		return this.requestRead({
+			path: `${s.object(e, t)}${De({
+				with_fields: n?.withFields ?? !1,
+				format: r.format,
+				hash_precision: r.hash_precision
+			})}`,
+			parser: oe
+		});
+	}
+	async delete(e, t) {
+		return this.requestWrite({
+			method: "DELETE",
+			path: s.object(e, t),
+			parser: J
+		});
+	}
+	async deleteMatching(e, t) {
+		return this.requestWrite({
+			method: "DELETE",
+			path: s.objects(e, t?.matchPattern),
+			parser: ue
+		});
+	}
+	async setFields(e, t, n, r) {
+		return this.requestWrite({
+			method: "POST",
+			path: s.fields(e, t),
+			body: {
+				fields: b(n),
+				xx: r?.xx ?? !1
+			},
+			parser: fe
+		});
+	}
+	async getField(e, t, n) {
+		return this.requestRead({
+			path: s.field(e, t, n),
+			parser: he
+		});
+	}
+	async expire(e, t, n) {
+		await this.requestWrite({
+			method: "POST",
+			path: s.expire(e, t),
+			body: { seconds: n },
+			parser: () => void 0
+		});
+	}
+	async persist(e, t) {
+		await this.requestWrite({
+			method: "DELETE",
+			path: s.expire(e, t),
+			parser: () => void 0
+		});
+	}
+	async ttl(e, t) {
+		return this.requestRead({
+			path: s.ttl(e, t),
+			parser: ge
+		});
+	}
+	async setJson(e, t, n, r, i) {
+		await this.requestWrite({
+			method: "POST",
+			path: s.jsonRoot(e, t),
+			body: {
+				path: n,
+				value: r,
+				raw: i?.raw ?? !1
+			},
+			parser: () => void 0
+		});
+	}
+	async getJson(e, t, n) {
+		return this.requestRead({
+			path: s.jsonPath(e, t, n),
+			parser: _e
+		});
+	}
+	async deleteJson(e, t, n) {
+		return this.requestWrite({
+			method: "DELETE",
+			path: s.jsonPath(e, t, n),
+			parser: (e) => Y(e, "deleted")
+		});
+	}
+	async nearby(e, t) {
+		return this.requestRead({
+			method: "POST",
+			path: s.nearby(e),
+			body: {
+				lat: t.lat,
+				lon: t.lon,
+				meters: t.meters,
+				options: D(t.options)
+			},
+			parser: O
+		});
+	}
+	async within(e, t) {
+		return this.requestRead({
+			method: "POST",
+			path: s.within(e),
+			body: {
+				area: w(t.area),
+				options: D(t.options)
+			},
+			parser: O
+		});
+	}
+	async intersects(e, t) {
+		return this.requestRead({
+			method: "POST",
+			path: s.intersects(e),
+			body: {
+				area: w(t.area),
+				options: D(t.options)
+			},
+			parser: O
+		});
+	}
+	async scan(e, t) {
+		return this.requestRead({
+			method: "POST",
+			path: s.scan(e),
+			body: D(t),
+			parser: O
+		});
+	}
+	async search(e, t) {
+		return this.requestRead({
+			method: "POST",
+			path: s.search(e),
+			body: D(t),
+			parser: O
+		});
+	}
+	async setChannel(t) {
+		return this.requestWrite({
+			method: "POST",
+			path: s.channels(),
+			body: {
+				name: t.name,
+				def: F(t.def)
+			},
+			parser: (t) => {
+				if (!t || typeof t != "object" || !("name" in t)) throw new e("invalid set channel response");
+				return String(t.name ?? "");
+			}
+		});
+	}
+	async deleteChannel(e) {
+		return this.requestWrite({
+			method: "DELETE",
+			path: s.channel(e),
+			parser: J
+		});
+	}
+	async channels(e) {
+		return this.requestRead({
+			path: s.channels(e),
+			parser: W
+		});
+	}
+	async getChannel(e) {
+		try {
+			return await this.requestRead({
+				path: s.channel(e),
+				parser: ye
+			});
+		} catch (e) {
+			if (e instanceof n && e.status === 404) return null;
+			throw e;
+		}
+	}
+	async setHook(e) {
+		await this.requestWrite({
+			method: "POST",
+			path: s.hooks(),
+			body: {
+				name: e.name,
+				endpoint: e.endpoint,
+				def: F(e.def)
+			},
+			parser: () => void 0
+		});
+	}
+	async deleteHook(e) {
+		return this.requestWrite({
+			method: "DELETE",
+			path: s.hook(e),
+			parser: J
+		});
+	}
+	async hooks(e) {
+		return this.requestRead({
+			path: s.hooks(e),
+			parser: be
+		});
+	}
+	async getHook(e) {
+		try {
+			return await this.requestRead({
+				path: s.hook(e),
+				parser: X
+			});
+		} catch (e) {
+			if (e instanceof n && e.status === 404) return null;
+			throw e;
+		}
+	}
+	async configGet(t) {
+		return this.requestLeader({
+			path: s.config(t),
+			parser: (t) => {
+				if (!t || typeof t != "object" || !("value" in t)) throw new e("invalid config response");
+				return String(t.value ?? "");
+			}
+		});
+	}
+	async configSet(e, t) {
+		await this.requestWrite({
+			method: "POST",
+			path: s.config(e),
+			body: { value: t },
+			parser: () => void 0
+		});
+	}
+	async configRewrite() {
+		await this.requestWrite({
+			method: "POST",
+			path: s.configRewrite(),
+			parser: () => void 0
+		});
+	}
+	async flushdb() {
+		await this.requestWrite({
+			method: "POST",
+			path: s.flushdb(),
+			parser: () => void 0
+		});
+	}
+	async gc() {
+		await this.requestWrite({
+			method: "POST",
+			path: s.gc(),
+			parser: () => void 0
+		});
+	}
+	async aofshrink() {
+		return this.requestWrite({
+			method: "POST",
+			path: s.aofshrink(),
+			parser: le
+		});
+	}
+	async webhookQueue() {
+		return this.requestLeader({
+			path: s.webhookQueue(),
+			parser: ce
+		});
+	}
+	async readonly(t) {
+		return this.requestWrite({
+			method: "POST",
+			path: s.readonly(),
+			body: { enabled: t },
+			parser: (t) => {
+				if (!t || typeof t != "object" || !("read_only" in t)) throw new e("invalid readonly response");
+				return !!t.read_only;
+			}
+		});
+	}
+	async timeout(e) {
+		return this.requestWrite({
+			method: "POST",
+			path: s.timeout(),
+			body: e,
+			parser: ve
+		});
+	}
+	async dropCollection(e) {
+		return this.requestWrite({
+			method: "DELETE",
+			path: s.collection(e),
+			parser: me
+		});
+	}
+	async connectWebSocket(e) {
+		return Q.connect({
+			url: e?.url ?? Oe(this.replicaRouter.getLeaderUrl()),
+			token: this.token,
+			webSocketFactory: this.webSocketFactory
+		});
+	}
+	async requestWrite(e) {
+		return this.transport.request(e);
+	}
+	async requestLeader(e) {
+		return this.transport.request(e);
+	}
+	async requestRead(e) {
+		let t = this.replicaRouter.getReadPreference();
+		if (t === "leader") return this.transport.request(e);
+		let n = await this.replicaRouter.getReadCandidates(this.transport);
+		if (t === "leaderPreferred") {
+			try {
+				return await this.requestLeader(e);
+			} catch (e) {
+				if (!$(e)) throw e;
+			}
+			for (let t of n) try {
+				return await this.transport.request({
+					...e,
+					baseUrl: t
+				});
+			} catch (e) {
+				if (!$(e)) throw e;
+			}
+			return this.requestLeader(e);
+		}
+		for (let t of n) try {
+			return await this.transport.request({
+				...e,
+				baseUrl: t
+			});
+		} catch (e) {
+			if (!$(e)) throw e;
+		}
+		return this.requestLeader(e);
+	}
+};
+function $(e) {
+	return e instanceof i || e instanceof t || !(e instanceof n);
+}
+function De(e) {
+	let t = new URLSearchParams();
+	for (let [n, r] of Object.entries(e)) r !== void 0 && t.set(n, String(r));
+	let n = t.toString();
+	return n ? `?${n}` : "";
+}
+function Oe(e) {
+	let t = new URL(e);
+	return t.protocol = t.protocol === "https:" ? "wss:" : "ws:", t.pathname = s.ws(), t.search = "", t.hash = "", t.toString();
+}
+//#endregion
+export { r as AuthError, n as HttpError, Ee as LatLngClient, e as LatLngError, Z as LatLngSubscription, Q as LatLngWebSocketClient, i as ServerUnavailableError, t as TimeoutError, ee as bounds, v as fieldEntries, h as geojson, m as hash, ne as jsonField, _ as numberField, z as parseGeofenceEvent, p as point, g as stringObject, te as textField };
+
+//# sourceMappingURL=index.js.map