@fkn/lib 0.9.29 → 0.9.31

package/rooms.js

@@ -3,18 +3,24 @@ 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
+	available: () => m,
+	create: () => g,
+	join: () => _,
+	open: () => h
 }), o = {
-	noSuchRoom: "rooms: no such room",
 	wrongKey: "rooms: wrong room key",
 	inviteNoKey: "rooms: the invite carries no key",
+	badName: "rooms: the name is not one a room can have",
+	badKeyOption: "rooms: the key is not 32 bytes base64url",
 	noSuchMember: "rooms: no such member",
+	noSuchMessage: "rooms: no such message",
 	roomFull: "rooms: the room is full",
-	tooManyRooms: "rooms: too many rooms",
 	tooManyConnections: "rooms: too many connections",
 	tooManyBlocks: "rooms: too many blocks",
+	tooManyClaims: "rooms: too many claims",
+	mailboxFull: "rooms: the mailbox is full",
+	outOfStorage: "rooms: the owner is out of storage",
+	outOfQuota: "rooms: out of daily bandwidth",
 	blocked: "rooms: you are blocked from this room",
 	cannotSend: "rooms: you cannot send here",
 	permissionDenied: "rooms: permission denied",
@@ -22,121 +28,160 @@ var a = /* @__PURE__ */ e({
 	ownerNotRemovable: "rooms: the owner cannot be removed",
 	ownerKeepsEvery: "rooms: the owner keeps every permission",
 	removeYourself: "rooms: you cannot remove yourself",
+	needsAccount: "rooms: claiming needs an account",
+	needsPremium: "rooms: claiming needs premium",
+	nameClaimed: "rooms: the name is claimed",
+	notClaimed: "rooms: the room is not claimed",
+	noMailbox: "rooms: the room keeps no messages",
+	badLimit: "rooms: the limit is out of range",
 	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",
+	notJoined: "rooms: not 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 () => {
+}, s = (e, t) => Object.assign(Error(t), { code: e }), c = (e) => e instanceof Error && typeof e.code == "string", l = {
+	send: !0,
+	receive: !0,
+	maxMessageBytes: 262144
+}, u = async () => {
 	if (!t) return;
 	let e = (await r("a room").catch(() => void 0))?.rooms;
-	return typeof e?.create == "function" ? e : void 0;
-}, u = () => {
+	return typeof e?.open == "function" ? e : void 0;
+}, d = () => {
 	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();
+}, f = (e) => e === "blocked" ? "blocked" : e === "not-found" ? "ended" : "unavailable", p = async (e) => {
+	let t = e.invite, r = e, a = 0, u = e.self, d = e.owner, p = e.claimed, m = e.mailbox, h = await e.defaults().catch(() => l), g = !1, _ = /* @__PURE__ */ new Set(), v = /* @__PURE__ */ new Set(), y = i("room"), b = () => {}, x = () => {}, S = new Promise((e) => {
+		x = e;
+	}), C = (e) => {
+		let t = [...v];
+		v.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 {
+	}, w = (e) => {
+		g || (g = !0, b(), _.clear(), y(), C(s("closed", o.ended)), x({ reason: e }));
+	}, T = (e) => {
+		if (!g) {
+			e.type === "defaults" && (h = e.defaults), e.type === "permissions" && e.id === u.id && (u = {
+				id: u.id,
+				permissions: e.permissions,
+				maxMessageBytes: e.maxMessageBytes
+			}), e.type === "claim" && (p = e.claimed, d = e.owner, p || (m = null));
+			for (let t of [..._]) try {
 				t(e);
 			} catch {}
 		}
-	}, S = (e, t) => {
-		Promise.resolve(e.on(x)).catch(() => {}), Promise.resolve(e.closed).then((e) => {
-			t === a && b(e.reason);
+	}, E = (e, t) => {
+		Promise.resolve(e.on(T)).catch(() => {}), Promise.resolve(e.closed).then((e) => {
+			t === a && w(e.reason);
 		}, () => {});
-	}, C = async (e, n) => {
-		if (typeof e?.join != "function") return b("unavailable");
+	}, D = async (e, n) => {
+		if (typeof e?.join != "function") return w("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);
+		if (g || n !== a) return;
+		if (!i) return w("unavailable");
+		if ("error" in i) return w(f(i.error));
+		if (i.self.id !== u.id) return Promise.resolve(i.leave()).catch(() => {}), w("unavailable");
+		r = i, u = i.self, d = i.owner, p = i.claimed, m = i.mailbox, E(i, n);
 		let o = await i.defaults().catch(() => void 0);
-		o && !f && n === a && (u = o);
+		o && !g && n === a && (h = o);
 	};
-	g = n((e, t) => {
+	b = 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);
+		a = t, !(g || n === 0 || n === t) && (C(s("unavailable", o.unavailable)), D(e.rooms, t));
+	}), E(e, a);
+	let O = async (e) => {
+		if (g) throw s("closed", o.ended);
 		let t = () => {}, n = new Promise((e, n) => {
 			t = n;
 		});
-		m.add(t);
+		v.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);
+			v.delete(t);
 		}
-	}, T = async (e) => {
-		let t = await w(e);
+	}, k = async (e) => {
+		let t = await O(e);
 		if ("error" in t) throw s(t.error, t.message);
+	}, A = async (e) => {
+		let t = await O(e);
+		if (typeof t == "object" && t && "error" in t) throw s(t.error, t.message);
+		return t;
 	};
 	return {
 		id: e.id,
+		name: e.name,
 		key: e.key,
 		invite: t,
 		get self() {
-			return l;
+			return u;
 		},
-		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);
+		get owner() {
+			return d;
+		},
+		get claimed() {
+			return p;
+		},
+		get mailbox() {
+			return m;
+		},
+		defaults: () => h,
+		members: () => O((e) => e.members()),
+		send: (e) => k((t) => t.send(e)),
+		edit: (e, t) => k((n) => n.edit(e, t)),
+		delete: (e, t) => k((n) => n.delete(e, t)),
+		backlog: (e, t) => A((n) => n.backlog(e, t)),
+		setDefault: (e, t) => k((n) => n.setDefault(e, t)),
+		limit: (e, t) => k((n) => n.limit(e, t)),
+		grant: (e, t) => k((n) => n.grant(e, t)),
+		revoke: (e, t) => k((n) => n.revoke(e, t)),
+		remove: (e) => k((t) => t.remove(e)),
+		block: (e) => k((t) => t.block(e)),
+		unblock: (e) => k((t) => t.unblock(e)),
+		claim: () => k((e) => e.claim()),
+		release: () => k((e) => e.release()),
+		usage: async () => {
+			let e = await A((e) => e.usage());
+			return m = e, e;
+		},
+		on: async (e) => g ? () => {} : (_.add(e), () => {
+			_.delete(e);
 		}),
 		leave: async () => {
-			await Promise.resolve(r.leave()).catch(() => {}), b("left");
+			await Promise.resolve(r.leave()).catch(() => {}), w("left");
 		},
-		closed: v
+		closed: S
 	};
-}, p = async () => {
-	let e = await l();
+}, m = async () => {
+	let e = await u();
 	return e ? e.available().catch(() => !1) : !1;
-}, m = async (e) => {
-	let t = await l();
+}, h = async (e, t) => {
+	if (typeof e != "string" || e.length === 0 || e.length > 72) throw s("invalid", o.badName);
+	let n = await u();
+	if (!n) throw s("unavailable", o.unavailable);
+	let r = await n.open(e, t).catch(d);
+	if ("error" in r) throw s(r.error, r.message);
+	return p(r);
+}, g = async (e) => {
+	let t = await u();
 	if (!t) throw s("unavailable", o.unavailable);
-	let n = await t.create(e).catch(u);
+	let n = await t.create(e).catch(d);
 	if ("error" in n) throw s(n.error, n.message);
-	return f(n);
-}, h = async (e, t) => {
+	return p(n);
+}, _ = 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();
+	let r = await u();
 	if (!r) throw s("unavailable", o.unavailable);
-	let i = await r.join(e, t).catch(u);
+	let i = await r.join(e, t).catch(d);
 	if ("error" in i) throw s(i.error, i.message);
-	return f(i);
+	return p(i);
 };
 //#endregion
-export { p as available, m as create, h as join, a as t };
+export { m as available, g as create, _ as join, h as open, a as t };