@protobase/client 0.59.0 → 0.59.2

package/dist/channel-binary-frame.js

@@ -0,0 +1,29 @@
+//#region src/channel-binary-frame.ts
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const lengthBytes = 4;
+/**
+* A binary frame of `/api/channels`, which carries a broadcast of bytes: the byte length of a JSON header, the header,
+* the message without its payload, then the payload's bytes.
+*/
+const encodeBinaryFrame = (header, bytes) => {
+	const head = encoder.encode(JSON.stringify(header));
+	const body = bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const frame = new Uint8Array(lengthBytes + head.length + body.length);
+	new DataView(frame.buffer).setUint32(0, head.length);
+	frame.set(head, lengthBytes);
+	frame.set(body, lengthBytes + head.length);
+	return frame.buffer;
+};
+/** The message a binary frame from the server carries, its bytes as its `payload`. */
+const decodeBinaryFrame = (frame) => {
+	const end = lengthBytes + new DataView(frame).getUint32(0);
+	return {
+		...JSON.parse(decoder.decode(new Uint8Array(frame, lengthBytes, end - lengthBytes))),
+		payload: frame.slice(end)
+	};
+};
+/** Whether a payload is bytes, sent as a binary frame. */
+const isBytes = (payload) => payload instanceof ArrayBuffer || ArrayBuffer.isView(payload);
+//#endregion
+export { decodeBinaryFrame, encodeBinaryFrame, isBytes };

package/dist/channel-connection.d.ts

@@ -2,7 +2,8 @@
 /** The part of the browser's `WebSocket` a connection uses, which a test hands its own of. */
 export type SocketLike = {
   readonly readyState: number;
-  send(data: string): void;
+  binaryType: string;
+  send(data: string | ArrayBuffer): void;
   close(code?: number): void;
   onopen: ((event: unknown) => void) | null;
   onmessage: ((event: {

package/dist/channel-connection.js

@@ -1,3 +1,4 @@
+import { decodeBinaryFrame, encodeBinaryFrame } from "./channel-binary-frame.js";
 import { ChannelRefusal } from "./channel-types.js";
 //#region src/channel-connection.ts
 /** How often the client pings, the server's `channelBounds.pingMs`; no pong in twice that drops the connection. */
@@ -38,6 +39,7 @@ const channelConnection = ({ url, token, socket: open, retryDelay, onOpen, onDow
 		sentToken = offered;
 		const current = open(url(), offered === void 0 ? [protocol] : [protocol, `bearer.${offered}`]);
 		socket = current;
+		current.binaryType = "arraybuffer";
 		current.onopen = () => {
 			failures = 0;
 			heardAt = Date.now();
@@ -50,8 +52,8 @@ const channelConnection = ({ url, token, socket: open, retryDelay, onOpen, onDow
 		};
 		current.onmessage = ({ data }) => {
 			heardAt = Date.now();
-			if (typeof data !== "string") return;
-			const message = JSON.parse(data);
+			if (typeof data !== "string" && !(data instanceof ArrayBuffer)) return;
+			const message = typeof data === "string" ? JSON.parse(data) : decodeBinaryFrame(data);
 			if (message.type !== "reply") return onMessage(message);
 			const waiting = pending.get(message.ref);
 			pending.delete(message.ref);
@@ -71,9 +73,9 @@ const channelConnection = ({ url, token, socket: open, retryDelay, onOpen, onDow
 			}, retryDelay(failures++));
 		};
 	};
-	const sendNow = (message) => {
+	const sendNow = (message, bytes) => {
 		if (socket?.readyState !== openState) return false;
-		socket.send(JSON.stringify(message));
+		socket.send(bytes === void 0 ? JSON.stringify(message) : encodeBinaryFrame(message, bytes));
 		return true;
 	};
 	return {
@@ -93,19 +95,19 @@ const channelConnection = ({ url, token, socket: open, retryDelay, onOpen, onDow
 			dropPending();
 			current?.close(1e3);
 		},
-		/** Sends a message with a ref, and resolves with its reply, or rejects with its refusal. */
-		request: (message) => new Promise((resolve, reject) => {
+		/** Sends a message with a ref, and bytes as its payload if any, and resolves with its reply, or rejects with its refusal. */
+		request: (message, bytes) => new Promise((resolve, reject) => {
 			const ref = String(++lastRef);
 			if (!sendNow({
 				...message,
 				ref
-			})) return reject(new ChannelRefusal("disconnected", "The connection is down"));
+			}, bytes)) return reject(new ChannelRefusal("disconnected", "The connection is down"));
 			pending.set(ref, {
 				resolve,
 				reject
 			});
 		}),
-		/** Sends a message that gets no reply; `false` when the socket is not open. */
+		/** Sends a message that gets no reply, and bytes as its payload if any; `false` when the socket is not open. */
 		post: sendNow
 	};
 };

package/dist/channel-types.d.ts

@@ -18,7 +18,7 @@ export type ChannelError = {
   code: string;
   message: string;
 };
-/** A broadcast as a channel hears it: with `server`, the app's own code sent it, and `user` is `null`. */
+/** A broadcast as a channel hears it, its payload JSON or, for bytes, an `ArrayBuffer`: with `server`, the app's own code sent it, and `user` is `null`. */
 export type ChannelMessage = {
   event: string;
   payload: unknown;

package/dist/channels.d.ts

@@ -14,8 +14,9 @@ export type Channel = {
   track: (state: unknown) => Promise<void>;
   untrack: () => Promise<void>;
   /**
-   * Broadcasts to the others on the channel; with `self` this connection hears it too. With `ack` it resolves once the
-   * server took it, or rejects with its `ChannelRefusal`; without, once it was sent.
+   * Broadcasts to the others on the channel: a JSON payload, or bytes in an `ArrayBuffer` or typed array, which the
+   * others hear as an `ArrayBuffer`. With `self` this connection hears it too. With `ack` it resolves once the server
+   * took it, or rejects with its `ChannelRefusal`; without, once it was sent.
    */
   send: (event: string, payload: unknown, options?: {
     self?: boolean;

package/dist/channels.js

@@ -1,3 +1,4 @@
+import { isBytes } from "./channel-binary-frame.js";
 import { ChannelRefusal } from "./channel-types.js";
 import { channelConnection } from "./channel-connection.js";
 import { encodeKey } from "@protobase/schema/internal";
@@ -145,21 +146,22 @@ const channelsClient = (options) => {
 			send: async (event, payload, { self, ack } = {}) => {
 				const name = joinedName();
 				if (name === void 0) throw notJoined();
+				const bytes = isBytes(payload) ? payload : void 0;
 				const message = {
 					type: "send",
 					channel: name,
 					event,
-					payload,
+					...bytes === void 0 && { payload },
 					...self && { self }
 				};
 				if (ack) {
 					await connection.request({
 						...message,
 						ack
-					});
+					}, bytes);
 					return;
 				}
-				if (!connection.post(message)) throw new ChannelRefusal("disconnected", "The connection is down");
+				if (!connection.post(message, bytes)) throw new ChannelRefusal("disconnected", "The connection is down");
 			},
 			on: (event, listener) => {
 				const listeners = channel.eventListeners.get(event) ?? /* @__PURE__ */ new Set();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/client",
-  "version": "0.59.0",
+  "version": "0.59.2",
   "description": "Typed fetch client for the Protobase REST API.",
   "license": "Apache-2.0",
   "repository": {
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "@better-auth/passkey": "^1.7.12",
-    "@protobase/layout": "0.59.0",
-    "@protobase/schema": "0.59.0",
+    "@protobase/layout": "0.59.2",
+    "@protobase/schema": "0.59.2",
     "@simplewebauthn/browser": "^13.3.0",
     "better-auth": "^1.7.12"
   }