@fkn/lib 0.9.72 → 0.9.73

package/websocket.d.ts

@@ -0,0 +1,48 @@
+type Handler<E extends Event> = ((event: E) => unknown) | null;
+/**
+ * The platform's `WebSocket`, opened by FKN's proxy on the node the session uses: the server sees that node's address,
+ * never the person's, and the proxy applies its egress validation, fair-use limits and metering as for a fetch. Its
+ * messages pass through the proxy's memory, so it is for servers the browser should not reach from its own address.
+ *
+ * It behaves as the platform's, events and their order included, with what the platform also refuses: a url that is
+ * not `ws:`, `wss:`, `http:` or `https:`, a fragment, a protocol that is not a token or is offered twice. It also
+ * refuses FKN's own hosts and a protocol named `fkn-proxy` or starting `fkn-proxy.`, which carry the target to the
+ * proxy. Nothing reconnects by itself. A Worker needs `relayWorker` from its page first; without it the socket fails
+ * once the broker has not answered within the deadline of `apiWithin`. `extensions` is always empty.
+ */
+export declare class WebSocket extends EventTarget {
+  #private;
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSING = 2;
+  static readonly CLOSED = 3;
+  readonly CONNECTING: 0;
+  readonly OPEN: 1;
+  readonly CLOSING: 2;
+  readonly CLOSED: 3;
+  readonly url: string;
+  readonly extensions = "";
+  constructor(url: string | URL, protocols?: string | string[]);
+  get readyState(): 0 | 1 | 2 | 3;
+  get protocol(): string;
+  get bufferedAmount(): number;
+  get binaryType(): BinaryType;
+  set binaryType(type: BinaryType);
+  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+  close(code?: number, reason?: string): void;
+  get onopen(): Handler<Event>;
+  set onopen(handler: Handler<Event>);
+  get onmessage(): Handler<MessageEvent>;
+  set onmessage(handler: Handler<MessageEvent>);
+  get onerror(): Handler<Event>;
+  set onerror(handler: Handler<Event>);
+  get onclose(): Handler<CloseEvent>;
+  set onclose(handler: Handler<CloseEvent>);
+}
+export interface WebSocket {
+  addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+  addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+  removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+  removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+export {};

package/websocket.js

@@ -0,0 +1,179 @@
+import { i as e } from "./broker-frame-AQDD3D9E.js";
+import { s as t } from "./api-De7vAubY.js";
+import { t as n } from "./busy-C1JPjoZ_.js";
+import { PROXY_WEBSOCKET_ENTRY as r, PROXY_WEBSOCKET_MARKER as i } from "./contract.js";
+// src/websocket.ts
+var a = 0, o = 1, s = 2, c = 3, l = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/, u = new TextEncoder(), d = {
+	code: 1006,
+	reason: "",
+	wasClean: !1,
+	error: !1
+}, f = (e) => {
+	let t;
+	try {
+		t = new URL(e, globalThis.document?.baseURI ?? globalThis.location?.href);
+	} catch {
+		throw new DOMException(`The URL '${e}' is invalid.`, "SyntaxError");
+	}
+	if (t.protocol === "http:" ? t.protocol = "ws:" : t.protocol === "https:" && (t.protocol = "wss:"), t.protocol !== "ws:" && t.protocol !== "wss:") throw new DOMException(`The URL's scheme must be either 'http', 'https', 'ws', or 'wss'. '${t.protocol}' is not allowed.`, "SyntaxError");
+	if (t.hash || t.href.endsWith("#")) throw new DOMException("The URL contains a fragment identifier.", "SyntaxError");
+	return t;
+}, p = (e) => {
+	if (typeof e == "string") return [e, u.encode(e).byteLength];
+	if (e instanceof Blob) return [e, e.size];
+	let t = ArrayBuffer.isView(e) ? new Uint8Array(e.buffer, e.byteOffset, e.byteLength) : new Uint8Array(e);
+	return [t.slice().buffer, t.byteLength];
+}, m = class extends EventTarget {
+	static CONNECTING = a;
+	static OPEN = o;
+	static CLOSING = s;
+	static CLOSED = c;
+	url;
+	extensions = "";
+	#e = "blob";
+	#t = a;
+	#n = "";
+	#r = 0;
+	#i;
+	#a;
+	#o;
+	#s;
+	#c = /* @__PURE__ */ new Map();
+	constructor(a, o = []) {
+		super();
+		let s = f(a), c = typeof o == "string" ? [o] : [...o];
+		if (new Set(c).size !== c.length || c.some((e) => !l.test(e))) throw new DOMException("The subprotocols are not unique tokens.", "SyntaxError");
+		if (c.some((e) => e === "fkn-proxy" || e.startsWith("fkn-proxy."))) throw new DOMException(`The subprotocol '${i}' and those starting '${r}' are FKN's.`, "SyntaxError");
+		if (e(s.hostname)) throw Error(`websocket refuses FKN platform domains (${s.hostname})`);
+		this.url = s.href, this.#i = s.origin, this.#s = n("websocket"), t("a websocket").then((e) => e.cloud.websocket({
+			url: this.url,
+			protocols: c
+		})).then((e) => this.#l(e)).catch(() => this.#u({
+			...d,
+			error: !0
+		}));
+	}
+	get readyState() {
+		return this.#t;
+	}
+	get protocol() {
+		return this.#n;
+	}
+	get bufferedAmount() {
+		return this.#r;
+	}
+	get binaryType() {
+		return this.#e;
+	}
+	set binaryType(e) {
+		(e === "blob" || e === "arraybuffer") && (this.#e = e);
+	}
+	send(e) {
+		if (this.#t === a) throw new DOMException("Failed to execute 'send' on 'WebSocket': Still in CONNECTING state.", "InvalidStateError");
+		let [t, n] = p(e);
+		this.#r += n, this.#t === o && this.#o.write(t).then(() => {
+			this.#r -= n;
+		}, () => {});
+	}
+	close(e, t) {
+		if (e !== void 0 && e !== 1e3 && (e < 3e3 || e > 4999)) throw new DOMException(`The close code must be either 1000, or between 3000 and 4999. ${e} is neither.`, "InvalidAccessError");
+		if (t !== void 0 && u.encode(t).byteLength > 123) throw new DOMException("The close reason must not be greater than 123 UTF-8 bytes.", "SyntaxError");
+		if (this.#t === s || this.#t === c) return;
+		if (e === void 0 && t !== void 0 && (e = 1e3), this.#t === a) {
+			this.#t = s, setTimeout(() => this.#u({
+				...d,
+				error: !0
+			}), 0);
+			return;
+		}
+		this.#t = s;
+		let n = this.#a;
+		this.#o.close().catch(() => {}).then(() => n.close(e, t)).catch(() => {});
+	}
+	async #l(e) {
+		if (this.#t !== a) {
+			e.close().catch(() => {});
+			return;
+		}
+		this.#a = e, this.#n = e.protocol, this.#o = e.writable.getWriter(), this.#t = o, this.dispatchEvent(new Event("open"));
+		let t = e.readable.getReader();
+		try {
+			for (;;) {
+				let { value: e, done: n } = await t.read();
+				if (n) break;
+				if (this.#t !== o) continue;
+				let r = typeof e == "string" || this.#e === "arraybuffer" ? e : new Blob([e]);
+				this.dispatchEvent(new MessageEvent("message", {
+					data: r,
+					origin: this.#i
+				}));
+			}
+		} catch {
+			return this.#u(d);
+		}
+		let n = await e.closed.then((e) => typeof e?.code == "number" ? e : d, () => d);
+		this.#u(n);
+	}
+	#u({ code: e, reason: t, wasClean: n, error: r }) {
+		this.#t !== c && (this.#t = c, this.#s(), r && this.dispatchEvent(new Event("error")), this.dispatchEvent(new CloseEvent("close", {
+			code: e,
+			reason: t,
+			wasClean: n
+		})));
+	}
+	#d(e) {
+		return this.#c.get(e)?.handler ?? null;
+	}
+	#f(e, t) {
+		let n = this.#c.get(e);
+		if (typeof t != "function") {
+			n && this.removeEventListener(e, n.listener), this.#c.delete(e);
+			return;
+		}
+		if (n) {
+			n.handler = t;
+			return;
+		}
+		let r = {
+			handler: t,
+			listener: (e) => {
+				r.handler.call(this, e);
+			}
+		};
+		this.#c.set(e, r), this.addEventListener(e, r.listener);
+	}
+	get onopen() {
+		return this.#d("open");
+	}
+	set onopen(e) {
+		this.#f("open", e);
+	}
+	get onmessage() {
+		return this.#d("message");
+	}
+	set onmessage(e) {
+		this.#f("message", e);
+	}
+	get onerror() {
+		return this.#d("error");
+	}
+	set onerror(e) {
+		this.#f("error", e);
+	}
+	get onclose() {
+		return this.#d("close");
+	}
+	set onclose(e) {
+		this.#f("close", e);
+	}
+};
+for (let [e, t] of Object.entries({
+	CONNECTING: a,
+	OPEN: o,
+	CLOSING: s,
+	CLOSED: c
+})) Object.defineProperty(m.prototype, e, {
+	value: t,
+	enumerable: !0
+});
+export { m as WebSocket };