@fkn/lib 0.9.27 → 0.9.29

package/rooms.js

@@ -0,0 +1,142 @@
+import { t as e } from "./rolldown-runtime-Dy4uBu1J.js";
+import { c as t, l as n, o as r } from "./api-DLvscoll.js";
+import { t as i } from "./busy-B189uX--.js";
+//#region src/rooms.ts
+var a = /* @__PURE__ */ e({
+	available: () => p,
+	create: () => m,
+	join: () => h
+}), o = {
+	noSuchRoom: "rooms: no such room",
+	wrongKey: "rooms: wrong room key",
+	inviteNoKey: "rooms: the invite carries no key",
+	noSuchMember: "rooms: no such member",
+	roomFull: "rooms: the room is full",
+	tooManyRooms: "rooms: too many rooms",
+	tooManyConnections: "rooms: too many connections",
+	tooManyBlocks: "rooms: too many blocks",
+	blocked: "rooms: you are blocked from this room",
+	cannotSend: "rooms: you cannot send here",
+	permissionDenied: "rooms: permission denied",
+	notOwner: "rooms: not the room owner",
+	ownerNotRemovable: "rooms: the owner cannot be removed",
+	ownerKeepsEvery: "rooms: the owner keeps every permission",
+	removeYourself: "rooms: you cannot remove yourself",
+	tooFast: "rooms: sending too fast",
+	tooLarge: "rooms: the message is too large",
+	unavailable: "rooms: rooms are unavailable",
+	notEnabled: "rooms: rooms are not available",
+	alreadyJoined: "rooms: already joined",
+	malformed: "rooms: malformed frame",
+	ended: "rooms: the room has ended"
+}, s = (e, t) => Object.assign(Error(t), { code: e }), c = (e) => e instanceof Error && typeof e.code == "string", l = async () => {
+	if (!t) return;
+	let e = (await r("a room").catch(() => void 0))?.rooms;
+	return typeof e?.create == "function" ? e : void 0;
+}, u = () => {
+	throw s("unavailable", o.unavailable);
+}, d = (e) => e === "blocked" ? "blocked" : e === "not-found" ? "ended" : "unavailable", f = async (e) => {
+	let t = e.invite, r = e, a = 0, l = e.self, u = await e.defaults().catch(() => ({
+		send: !0,
+		receive: !0
+	})), f = !1, p = /* @__PURE__ */ new Set(), m = /* @__PURE__ */ new Set(), h = i("room"), g = () => {}, _ = () => {}, v = new Promise((e) => {
+		_ = e;
+	}), y = (e) => {
+		let t = [...m];
+		m.clear();
+		for (let n of t) try {
+			n(e);
+		} catch {}
+	}, b = (e) => {
+		f || (f = !0, g(), p.clear(), h(), y(s("closed", o.ended)), _({ reason: e }));
+	}, x = (e) => {
+		if (!f) {
+			e.type === "defaults" && (u = e.defaults), e.type === "permissions" && e.id === l.id && (l = {
+				id: l.id,
+				permissions: e.permissions
+			});
+			for (let t of [...p]) try {
+				t(e);
+			} catch {}
+		}
+	}, S = (e, t) => {
+		Promise.resolve(e.on(x)).catch(() => {}), Promise.resolve(e.closed).then((e) => {
+			t === a && b(e.reason);
+		}, () => {});
+	}, C = async (e, n) => {
+		if (typeof e?.join != "function") return b("unavailable");
+		let i = await e.join(t).catch(() => void 0);
+		if (f || n !== a) return;
+		if (!i) return b("unavailable");
+		if ("error" in i) return b(d(i.error));
+		if (i.self.id !== l.id) return Promise.resolve(i.leave()).catch(() => {}), b("unavailable");
+		r = i, l = i.self, S(i, n);
+		let o = await i.defaults().catch(() => void 0);
+		o && !f && n === a && (u = o);
+	};
+	g = n((e, t) => {
+		let n = a;
+		a = t, !(f || n === 0 || n === t) && (y(s("unavailable", o.unavailable)), C(e.rooms, t));
+	}), S(e, a);
+	let w = async (e) => {
+		if (f) throw s("closed", o.ended);
+		let t = () => {}, n = new Promise((e, n) => {
+			t = n;
+		});
+		m.add(t);
+		try {
+			return await Promise.race([Promise.resolve(e(r)), n]);
+		} catch (e) {
+			throw c(e) ? e : s("unavailable", o.unavailable);
+		} finally {
+			m.delete(t);
+		}
+	}, T = async (e) => {
+		let t = await w(e);
+		if ("error" in t) throw s(t.error, t.message);
+	};
+	return {
+		id: e.id,
+		key: e.key,
+		invite: t,
+		get self() {
+			return l;
+		},
+		owner: e.owner,
+		defaults: () => u,
+		members: () => w((e) => e.members()),
+		send: (e) => T((t) => t.send(e)),
+		setDefault: (e, t) => T((n) => n.setDefault(e, t)),
+		grant: (e, t) => T((n) => n.grant(e, t)),
+		revoke: (e, t) => T((n) => n.revoke(e, t)),
+		remove: (e) => T((t) => t.remove(e)),
+		block: (e) => T((t) => t.block(e)),
+		unblock: (e) => T((t) => t.unblock(e)),
+		on: async (e) => f ? () => {} : (p.add(e), () => {
+			p.delete(e);
+		}),
+		leave: async () => {
+			await Promise.resolve(r.leave()).catch(() => {}), b("left");
+		},
+		closed: v
+	};
+}, p = async () => {
+	let e = await l();
+	return e ? e.available().catch(() => !1) : !1;
+}, m = async (e) => {
+	let t = await l();
+	if (!t) throw s("unavailable", o.unavailable);
+	let n = await t.create(e).catch(u);
+	if ("error" in n) throw s(n.error, n.message);
+	return f(n);
+}, h = async (e, t) => {
+	let n = typeof e == "string" ? e.indexOf(".") : -1;
+	if (n <= 0 || n === e.length - 1) throw s("invalid", o.inviteNoKey);
+	let r = await l();
+	if (!r) throw s("unavailable", o.unavailable);
+	let i = await r.join(e, t).catch(u);
+	if ("error" in i) throw s(i.error, i.message);
+	return f(i);
+};
+//#endregion
+export { p as available, m as create, h as join, a as t };