@statewalker/webrun-streams-ws 0.3.0 → 0.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +6 -5
- package/dist/index.js +26 -75
- package/dist/message-target.d.ts +24 -23
- package/dist/message-target.d.ts.map +1 -1
- package/package.json +7 -5
- package/src/message-target.ts +61 -116
package/README.md
CHANGED
|
@@ -31,8 +31,9 @@ runs over any other transport that implements the seam.
|
|
|
31
31
|
pnpm add @statewalker/webrun-streams-ws @statewalker/webrun-rpc @statewalker/webrun-msgpack
|
|
32
32
|
```
|
|
33
33
|
|
|
34
|
-
The pipe
|
|
35
|
-
`@statewalker/webrun-msgpack` are
|
|
34
|
+
The pipe is built on `newMessagePipe` from `@statewalker/webrun-streams`, its one
|
|
35
|
+
runtime dependency; `@statewalker/webrun-rpc` and `@statewalker/webrun-msgpack` are
|
|
36
|
+
what you run over it. No peer dependencies.
|
|
36
37
|
One entry point, `.`.
|
|
37
38
|
|
|
38
39
|
- **Browser and worker**: `openWebSocket` uses the global `WebSocket`.
|
|
@@ -252,9 +253,9 @@ shared CI hardware is unreliable, and it is excluded from `pnpm test`.
|
|
|
252
253
|
|
|
253
254
|
### Dependencies
|
|
254
255
|
|
|
255
|
-
-
|
|
256
|
-
|
|
257
|
-
|
|
256
|
+
- `@statewalker/webrun-streams` at runtime, for `newMessagePipe`: the pipe module every transport adapter shares (listeners, delivery, life, the byte check, the frame ceiling, drain, close), so a pipe rule is fixed once for all of them (#151). The target is a `MessageTarget` by shape and carries its own `closeSignal` and `maxMessageSize`, so `overPipe(target, { codec, side })` needs nothing else.
|
|
257
|
+
`messageTargetOverWebSocket` takes `maxFrameBytes` and `maxMessageSize`
|
|
258
|
+
options, both unset by default.
|
|
258
259
|
- `ws`, `@statewalker/webrun-rpc`, `@statewalker/webrun-msgpack` and
|
|
259
260
|
`@statewalker/webrun-streams-conformance` are dev dependencies used only by
|
|
260
261
|
the tests; consumers supply their own `webrun-rpc` and codec.
|
package/dist/index.js
CHANGED
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { DEFAULT_DRAIN_LOW_WATER, newMessagePipe } from "@statewalker/webrun-streams";
|
|
1
2
|
//#region src/websocket-like.ts
|
|
2
3
|
const WS_READY_STATE = {
|
|
3
4
|
CONNECTING: 0,
|
|
@@ -7,15 +8,12 @@ const WS_READY_STATE = {
|
|
|
7
8
|
};
|
|
8
9
|
//#endregion
|
|
9
10
|
//#region src/message-target.ts
|
|
10
|
-
/** How often `whenDrained` looks at `bufferedAmount`: a WebSocket has no drain event. */
|
|
11
|
-
const DRAIN_POLL_MS = 5;
|
|
12
11
|
/**
|
|
13
12
|
* `whenDrained` resolves once `bufferedAmount` is at most this: the socket can
|
|
14
13
|
* take more. Waiting for zero would make a sender that waits before every
|
|
15
14
|
* frame (`overPipe`'s `frameSize`) pause a poll interval per frame.
|
|
16
15
|
*/
|
|
17
|
-
const DRAIN_LOW_WATER =
|
|
18
|
-
const encoder = new TextEncoder();
|
|
16
|
+
const DRAIN_LOW_WATER = DEFAULT_DRAIN_LOW_WATER;
|
|
19
17
|
/**
|
|
20
18
|
* One open WebSocket as a pipe of messages, for a multiplexer to run over:
|
|
21
19
|
*
|
|
@@ -29,86 +27,39 @@ const encoder = new TextEncoder();
|
|
|
29
27
|
* The socket must be `OPEN`. Binary messages arrive as `Uint8Array`, in order:
|
|
30
28
|
* a browser socket still on the default `binaryType` "blob" is switched to
|
|
31
29
|
* "arraybuffer", because reading a `Blob` is asynchronous and would let a later
|
|
32
|
-
* message overtake it. A text message arrives as its UTF-8 bytes
|
|
33
|
-
*
|
|
34
|
-
*
|
|
30
|
+
* message overtake it. A text message arrives as its UTF-8 bytes; anything
|
|
31
|
+
* else ends the pipe with a `TypeError`. Messages reaching no listener are
|
|
32
|
+
* dropped, as on a `MessagePort`. Built on `newMessagePipe`
|
|
33
|
+
* (`@statewalker/webrun-streams`), which owns the pipe's rules.
|
|
35
34
|
*/
|
|
36
|
-
function messageTargetOverWebSocket(ws) {
|
|
35
|
+
function messageTargetOverWebSocket(ws, options = {}) {
|
|
37
36
|
if (ws.readyState !== WS_READY_STATE.OPEN) throw new Error(`messageTargetOverWebSocket: WebSocket is in readyState ${ws.readyState}, expected OPEN (1)`);
|
|
38
37
|
if (ws.binaryType !== void 0 && ws.binaryType !== "arraybuffer" && ws.binaryType !== "nodebuffer") ws.binaryType = "arraybuffer";
|
|
39
|
-
const
|
|
40
|
-
const
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
for (const listener of [...listeners]) try {
|
|
44
|
-
Promise.resolve(listener(event)).catch(() => void 0);
|
|
45
|
-
} catch {}
|
|
38
|
+
const onMessage = (event) => control.deliver(event.data);
|
|
39
|
+
const onClose = (event) => {
|
|
40
|
+
const code = event?.code;
|
|
41
|
+
control.end(/* @__PURE__ */ new Error(`webrun-streams-ws: the WebSocket closed${code ? ` (code ${code})` : ""}`));
|
|
46
42
|
};
|
|
47
|
-
const
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
try {
|
|
43
|
+
const control = newMessagePipe({
|
|
44
|
+
send: (bytes) => ws.send(bytes),
|
|
45
|
+
canSend: () => ws.readyState === WS_READY_STATE.OPEN,
|
|
46
|
+
bufferedAmount: () => ws.bufferedAmount ?? 0,
|
|
47
|
+
close: (local) => {
|
|
48
|
+
ws.removeEventListener("message", onMessage);
|
|
49
|
+
ws.removeEventListener("close", onClose);
|
|
50
|
+
if (local) try {
|
|
55
51
|
ws.close();
|
|
56
52
|
} catch {}
|
|
57
53
|
}
|
|
58
|
-
}
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
};
|
|
65
|
-
const onClose = (event) => {
|
|
66
|
-
const code = event?.code;
|
|
67
|
-
end(/* @__PURE__ */ new Error(`webrun-streams-ws: the WebSocket closed${code ? ` (code ${code})` : ""}`));
|
|
68
|
-
};
|
|
54
|
+
}, {
|
|
55
|
+
name: "webrun-streams-ws",
|
|
56
|
+
textAsBytes: true,
|
|
57
|
+
maxFrameBytes: options.maxFrameBytes,
|
|
58
|
+
maxMessageSize: options.maxMessageSize
|
|
59
|
+
});
|
|
69
60
|
ws.addEventListener("message", onMessage);
|
|
70
61
|
ws.addEventListener("close", onClose);
|
|
71
|
-
return
|
|
72
|
-
signal: life.signal,
|
|
73
|
-
target: {
|
|
74
|
-
addEventListener: (_type, listener) => {
|
|
75
|
-
listeners.add(listener);
|
|
76
|
-
},
|
|
77
|
-
removeEventListener: (_type, listener) => {
|
|
78
|
-
listeners.delete(listener);
|
|
79
|
-
},
|
|
80
|
-
postMessage(message) {
|
|
81
|
-
const bytes = toBytes(message);
|
|
82
|
-
if (!bytes) throw new TypeError(`webrun-streams-ws: a byte pipe carries Uint8Array, ArrayBuffer or a view, got ${Object.prototype.toString.call(message)}`);
|
|
83
|
-
if (life.signal.aborted || ws.readyState !== WS_READY_STATE.OPEN) return;
|
|
84
|
-
ws.send(bytes);
|
|
85
|
-
},
|
|
86
|
-
async close() {
|
|
87
|
-
listeners.clear();
|
|
88
|
-
end(/* @__PURE__ */ new Error("webrun-streams-ws: closed locally"));
|
|
89
|
-
try {
|
|
90
|
-
ws.close();
|
|
91
|
-
} catch {}
|
|
92
|
-
},
|
|
93
|
-
get bufferedAmount() {
|
|
94
|
-
return ws.bufferedAmount ?? 0;
|
|
95
|
-
},
|
|
96
|
-
whenDrained() {
|
|
97
|
-
return new Promise((resolve) => {
|
|
98
|
-
const check = () => {
|
|
99
|
-
if (life.signal.aborted || (ws.bufferedAmount ?? 0) <= 262144) resolve();
|
|
100
|
-
else setTimeout(check, DRAIN_POLL_MS).unref?.();
|
|
101
|
-
};
|
|
102
|
-
check();
|
|
103
|
-
});
|
|
104
|
-
}
|
|
105
|
-
}
|
|
106
|
-
};
|
|
107
|
-
}
|
|
108
|
-
function toBytes(data) {
|
|
109
|
-
if (data instanceof Uint8Array) return data;
|
|
110
|
-
if (data instanceof ArrayBuffer) return new Uint8Array(data);
|
|
111
|
-
if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
|
|
62
|
+
return control.pipe;
|
|
112
63
|
}
|
|
113
64
|
/** Opens a WebSocket and resolves once it is `OPEN`; rejects if it fails or closes first. */
|
|
114
65
|
async function openWebSocket(params) {
|
package/dist/message-target.d.ts
CHANGED
|
@@ -1,30 +1,31 @@
|
|
|
1
|
+
import { type MessagePipe, type MessagePipeTarget } from "@statewalker/webrun-streams";
|
|
1
2
|
import { type WebSocketLike } from "./websocket-like.js";
|
|
2
|
-
type Listener = (event: MessageEvent) => void | Promise<void>;
|
|
3
3
|
/** What `messageTargetOverWebSocket` gives: a pipe of bytes, and its life. */
|
|
4
|
-
export interface WebSocketMessageTarget {
|
|
4
|
+
export interface WebSocketMessageTarget extends MessagePipe {
|
|
5
5
|
/**
|
|
6
6
|
* A `MessageTarget` (as `@statewalker/webrun-rpc` defines it) whose messages
|
|
7
|
-
* are `Uint8Array`s, one WebSocket message each.
|
|
7
|
+
* are `Uint8Array`s, one WebSocket message each. `bufferedAmount` is the
|
|
8
|
+
* socket's; `whenDrained` resolves once it is at most
|
|
9
|
+
* {@link DRAIN_LOW_WATER}, or the socket has closed.
|
|
8
10
|
*/
|
|
9
|
-
target:
|
|
10
|
-
addEventListener(type: "message", listener: Listener): void;
|
|
11
|
-
removeEventListener(type: "message", listener: Listener): void;
|
|
12
|
-
/** Sends one binary message. Throws `TypeError` for anything but bytes. */
|
|
13
|
-
postMessage(message: unknown): void;
|
|
14
|
-
/** Closes the socket. */
|
|
15
|
-
close(): Promise<void>;
|
|
16
|
-
/** The socket's `bufferedAmount`: bytes sent and not yet written out. */
|
|
17
|
-
readonly bufferedAmount: number;
|
|
18
|
-
/** Resolves once `bufferedAmount` is at most {@link DRAIN_LOW_WATER}, or the socket has closed. */
|
|
19
|
-
whenDrained(): Promise<void>;
|
|
20
|
-
};
|
|
11
|
+
target: MessagePipeTarget;
|
|
21
12
|
/**
|
|
22
|
-
* Aborts when the socket closes, with an `Error` saying how
|
|
23
|
-
* `multiplexPort`'s / `overPipe`'s
|
|
24
|
-
* multiplexer and every port on it at
|
|
13
|
+
* Aborts when the socket closes, with an `Error` saying how; the same as
|
|
14
|
+
* `target.closeSignal`. Pass it as `multiplexPort`'s / `overPipe`'s
|
|
15
|
+
* `signal`, so a dead peer closes the multiplexer and every port on it at
|
|
16
|
+
* once instead of leaving them open.
|
|
25
17
|
*/
|
|
26
18
|
signal: AbortSignal;
|
|
27
19
|
}
|
|
20
|
+
export interface MessageTargetOverWebSocketOptions {
|
|
21
|
+
/**
|
|
22
|
+
* The largest message posted; past it the pipe ends with a `RangeError`.
|
|
23
|
+
* Default: none, a WebSocket carries messages of any size.
|
|
24
|
+
*/
|
|
25
|
+
maxFrameBytes?: number;
|
|
26
|
+
/** The payload ceiling to report, for `overPipe`'s `maxMessageSize`. Default: none. */
|
|
27
|
+
maxMessageSize?: number;
|
|
28
|
+
}
|
|
28
29
|
/**
|
|
29
30
|
* `whenDrained` resolves once `bufferedAmount` is at most this: the socket can
|
|
30
31
|
* take more. Waiting for zero would make a sender that waits before every
|
|
@@ -44,11 +45,12 @@ export declare const DRAIN_LOW_WATER: number;
|
|
|
44
45
|
* The socket must be `OPEN`. Binary messages arrive as `Uint8Array`, in order:
|
|
45
46
|
* a browser socket still on the default `binaryType` "blob" is switched to
|
|
46
47
|
* "arraybuffer", because reading a `Blob` is asynchronous and would let a later
|
|
47
|
-
* message overtake it. A text message arrives as its UTF-8 bytes
|
|
48
|
-
*
|
|
49
|
-
*
|
|
48
|
+
* message overtake it. A text message arrives as its UTF-8 bytes; anything
|
|
49
|
+
* else ends the pipe with a `TypeError`. Messages reaching no listener are
|
|
50
|
+
* dropped, as on a `MessagePort`. Built on `newMessagePipe`
|
|
51
|
+
* (`@statewalker/webrun-streams`), which owns the pipe's rules.
|
|
50
52
|
*/
|
|
51
|
-
export declare function messageTargetOverWebSocket(ws: WebSocketLike): WebSocketMessageTarget;
|
|
53
|
+
export declare function messageTargetOverWebSocket(ws: WebSocketLike, options?: MessageTargetOverWebSocketOptions): WebSocketMessageTarget;
|
|
52
54
|
export interface OpenWebSocketParams {
|
|
53
55
|
/** WebSocket URL (`ws://` or `wss://`). */
|
|
54
56
|
url: string;
|
|
@@ -64,5 +66,4 @@ export interface OpenWebSocketParams {
|
|
|
64
66
|
export declare function openWebSocket(params: OpenWebSocketParams): Promise<WebSocketLike>;
|
|
65
67
|
/** Resolves once `ws` is `OPEN`; rejects if it fails or closes first. */
|
|
66
68
|
export declare function waitForOpen(ws: WebSocketLike): Promise<void>;
|
|
67
|
-
export {};
|
|
68
69
|
//# sourceMappingURL=message-target.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"message-target.d.ts","sourceRoot":"","sources":["../src/message-target.ts"],"names":[],"mappings":"AAAA,OAAO,
|
|
1
|
+
{"version":3,"file":"message-target.d.ts","sourceRoot":"","sources":["../src/message-target.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EAEvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,KAAK,aAAa,EAAkB,MAAM,qBAAqB,CAAC;AAEzE,8EAA8E;AAC9E,MAAM,WAAW,sBAAuB,SAAQ,WAAW;IACzD;;;;;OAKG;IACH,MAAM,EAAE,iBAAiB,CAAC;IAC1B;;;;;OAKG;IACH,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,iCAAiC;IAChD;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uFAAuF;IACvF,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAA0B,CAAC;AAEvD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,aAAa,EACjB,OAAO,GAAE,iCAAsC,GAC9C,sBAAsB,CAiDxB;AAED,MAAM,WAAW,mBAAmB;IAClC,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC9B;;;OAGG;IACH,aAAa,CAAC,EAAE,KACd,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,KAC1B,aAAa,CAAC;CACpB;AAED,6FAA6F;AAC7F,wBAAsB,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC,CAUvF;AAED,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,EAAE,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAwB5D"}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@statewalker/webrun-streams-ws",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.4.0",
|
|
4
4
|
"private": false,
|
|
5
5
|
"type": "module",
|
|
6
6
|
"description": "WebSocket-backed Connect/Serve adapter in the webrun-streams-* family",
|
|
@@ -29,6 +29,9 @@
|
|
|
29
29
|
"dist",
|
|
30
30
|
"src"
|
|
31
31
|
],
|
|
32
|
+
"dependencies": {
|
|
33
|
+
"@statewalker/webrun-streams": "^0.5.0"
|
|
34
|
+
},
|
|
32
35
|
"devDependencies": {
|
|
33
36
|
"@biomejs/biome": "^2.5.15",
|
|
34
37
|
"@types/node": "^26.6.4",
|
|
@@ -38,10 +41,9 @@
|
|
|
38
41
|
"typescript": "^7.0.2",
|
|
39
42
|
"vitest": "^5.0.5",
|
|
40
43
|
"ws": "^8.22.0",
|
|
41
|
-
"@statewalker/webrun-streams-conformance": "^0.
|
|
42
|
-
"@statewalker/webrun-
|
|
43
|
-
"@statewalker/webrun-
|
|
44
|
-
"@statewalker/webrun-rpc": "^0.11.0"
|
|
44
|
+
"@statewalker/webrun-streams-conformance": "^0.6.0",
|
|
45
|
+
"@statewalker/webrun-rpc": "^0.13.0",
|
|
46
|
+
"@statewalker/webrun-msgpack": "^0.12.0"
|
|
45
47
|
},
|
|
46
48
|
"sideEffects": false,
|
|
47
49
|
"publishConfig": {
|
package/src/message-target.ts
CHANGED
|
@@ -1,43 +1,45 @@
|
|
|
1
|
+
import {
|
|
2
|
+
DEFAULT_DRAIN_LOW_WATER,
|
|
3
|
+
type MessagePipe,
|
|
4
|
+
type MessagePipeTarget,
|
|
5
|
+
newMessagePipe,
|
|
6
|
+
} from "@statewalker/webrun-streams";
|
|
1
7
|
import { type WebSocketLike, WS_READY_STATE } from "./websocket-like.js";
|
|
2
8
|
|
|
3
|
-
type Listener = (event: MessageEvent) => void | Promise<void>;
|
|
4
|
-
|
|
5
9
|
/** What `messageTargetOverWebSocket` gives: a pipe of bytes, and its life. */
|
|
6
|
-
export interface WebSocketMessageTarget {
|
|
10
|
+
export interface WebSocketMessageTarget extends MessagePipe {
|
|
7
11
|
/**
|
|
8
12
|
* A `MessageTarget` (as `@statewalker/webrun-rpc` defines it) whose messages
|
|
9
|
-
* are `Uint8Array`s, one WebSocket message each.
|
|
13
|
+
* are `Uint8Array`s, one WebSocket message each. `bufferedAmount` is the
|
|
14
|
+
* socket's; `whenDrained` resolves once it is at most
|
|
15
|
+
* {@link DRAIN_LOW_WATER}, or the socket has closed.
|
|
10
16
|
*/
|
|
11
|
-
target:
|
|
12
|
-
addEventListener(type: "message", listener: Listener): void;
|
|
13
|
-
removeEventListener(type: "message", listener: Listener): void;
|
|
14
|
-
/** Sends one binary message. Throws `TypeError` for anything but bytes. */
|
|
15
|
-
postMessage(message: unknown): void;
|
|
16
|
-
/** Closes the socket. */
|
|
17
|
-
close(): Promise<void>;
|
|
18
|
-
/** The socket's `bufferedAmount`: bytes sent and not yet written out. */
|
|
19
|
-
readonly bufferedAmount: number;
|
|
20
|
-
/** Resolves once `bufferedAmount` is at most {@link DRAIN_LOW_WATER}, or the socket has closed. */
|
|
21
|
-
whenDrained(): Promise<void>;
|
|
22
|
-
};
|
|
17
|
+
target: MessagePipeTarget;
|
|
23
18
|
/**
|
|
24
|
-
* Aborts when the socket closes, with an `Error` saying how
|
|
25
|
-
* `multiplexPort`'s / `overPipe`'s
|
|
26
|
-
* multiplexer and every port on it at
|
|
19
|
+
* Aborts when the socket closes, with an `Error` saying how; the same as
|
|
20
|
+
* `target.closeSignal`. Pass it as `multiplexPort`'s / `overPipe`'s
|
|
21
|
+
* `signal`, so a dead peer closes the multiplexer and every port on it at
|
|
22
|
+
* once instead of leaving them open.
|
|
27
23
|
*/
|
|
28
24
|
signal: AbortSignal;
|
|
29
25
|
}
|
|
30
26
|
|
|
31
|
-
|
|
32
|
-
|
|
27
|
+
export interface MessageTargetOverWebSocketOptions {
|
|
28
|
+
/**
|
|
29
|
+
* The largest message posted; past it the pipe ends with a `RangeError`.
|
|
30
|
+
* Default: none, a WebSocket carries messages of any size.
|
|
31
|
+
*/
|
|
32
|
+
maxFrameBytes?: number;
|
|
33
|
+
/** The payload ceiling to report, for `overPipe`'s `maxMessageSize`. Default: none. */
|
|
34
|
+
maxMessageSize?: number;
|
|
35
|
+
}
|
|
36
|
+
|
|
33
37
|
/**
|
|
34
38
|
* `whenDrained` resolves once `bufferedAmount` is at most this: the socket can
|
|
35
39
|
* take more. Waiting for zero would make a sender that waits before every
|
|
36
40
|
* frame (`overPipe`'s `frameSize`) pause a poll interval per frame.
|
|
37
41
|
*/
|
|
38
|
-
export const DRAIN_LOW_WATER =
|
|
39
|
-
|
|
40
|
-
const encoder = new TextEncoder();
|
|
42
|
+
export const DRAIN_LOW_WATER = DEFAULT_DRAIN_LOW_WATER;
|
|
41
43
|
|
|
42
44
|
/**
|
|
43
45
|
* One open WebSocket as a pipe of messages, for a multiplexer to run over:
|
|
@@ -52,11 +54,15 @@ const encoder = new TextEncoder();
|
|
|
52
54
|
* The socket must be `OPEN`. Binary messages arrive as `Uint8Array`, in order:
|
|
53
55
|
* a browser socket still on the default `binaryType` "blob" is switched to
|
|
54
56
|
* "arraybuffer", because reading a `Blob` is asynchronous and would let a later
|
|
55
|
-
* message overtake it. A text message arrives as its UTF-8 bytes
|
|
56
|
-
*
|
|
57
|
-
*
|
|
57
|
+
* message overtake it. A text message arrives as its UTF-8 bytes; anything
|
|
58
|
+
* else ends the pipe with a `TypeError`. Messages reaching no listener are
|
|
59
|
+
* dropped, as on a `MessagePort`. Built on `newMessagePipe`
|
|
60
|
+
* (`@statewalker/webrun-streams`), which owns the pipe's rules.
|
|
58
61
|
*/
|
|
59
|
-
export function messageTargetOverWebSocket(
|
|
62
|
+
export function messageTargetOverWebSocket(
|
|
63
|
+
ws: WebSocketLike,
|
|
64
|
+
options: MessageTargetOverWebSocketOptions = {},
|
|
65
|
+
): WebSocketMessageTarget {
|
|
60
66
|
if (ws.readyState !== WS_READY_STATE.OPEN) {
|
|
61
67
|
throw new Error(
|
|
62
68
|
`messageTargetOverWebSocket: WebSocket is in readyState ${ws.readyState}, expected OPEN (1)`,
|
|
@@ -71,101 +77,40 @@ export function messageTargetOverWebSocket(ws: WebSocketLike): WebSocketMessageT
|
|
|
71
77
|
ws.binaryType !== "nodebuffer"
|
|
72
78
|
)
|
|
73
79
|
ws.binaryType = "arraybuffer";
|
|
74
|
-
const listeners = new Set<Listener>();
|
|
75
|
-
const life = new AbortController();
|
|
76
80
|
|
|
77
|
-
const
|
|
78
|
-
const event = new MessageEvent("message", { data });
|
|
79
|
-
for (const listener of [...listeners]) {
|
|
80
|
-
try {
|
|
81
|
-
// One listener's fault, thrown or rejected, must not stop delivery.
|
|
82
|
-
Promise.resolve(listener(event)).catch(() => undefined);
|
|
83
|
-
} catch {}
|
|
84
|
-
}
|
|
85
|
-
};
|
|
86
|
-
const onMessage = (event: MessageEvent): void => {
|
|
87
|
-
if (life.signal.aborted) return;
|
|
88
|
-
const bytes = toBytes(event.data);
|
|
89
|
-
if (bytes) deliver(bytes);
|
|
90
|
-
else if (typeof event.data === "string") deliver(encoder.encode(event.data));
|
|
91
|
-
else {
|
|
92
|
-
// Dropping it would lose a multiplexer envelope and hang its call: fail loudly.
|
|
93
|
-
end(
|
|
94
|
-
new TypeError(
|
|
95
|
-
`webrun-streams-ws: a message arrived as ${Object.prototype.toString.call(event.data)}; set binaryType to "arraybuffer" or "nodebuffer"`,
|
|
96
|
-
),
|
|
97
|
-
);
|
|
98
|
-
try {
|
|
99
|
-
ws.close();
|
|
100
|
-
} catch {}
|
|
101
|
-
}
|
|
102
|
-
};
|
|
103
|
-
const end = (reason: Error): void => {
|
|
104
|
-
if (life.signal.aborted) return;
|
|
105
|
-
ws.removeEventListener("message", onMessage);
|
|
106
|
-
ws.removeEventListener("close", onClose);
|
|
107
|
-
life.abort(reason);
|
|
108
|
-
};
|
|
81
|
+
const onMessage = (event: MessageEvent): void => control.deliver(event.data);
|
|
109
82
|
const onClose = (event?: unknown): void => {
|
|
110
83
|
const code = (event as { code?: number } | undefined)?.code;
|
|
111
|
-
end(
|
|
84
|
+
control.end(
|
|
85
|
+
new Error(`webrun-streams-ws: the WebSocket closed${code ? ` (code ${code})` : ""}`),
|
|
86
|
+
);
|
|
112
87
|
};
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
},
|
|
126
|
-
postMessage(message) {
|
|
127
|
-
const bytes = toBytes(message);
|
|
128
|
-
if (!bytes) {
|
|
129
|
-
throw new TypeError(
|
|
130
|
-
`webrun-streams-ws: a byte pipe carries Uint8Array, ArrayBuffer or a view, got ${Object.prototype.toString.call(message)}`,
|
|
131
|
-
);
|
|
88
|
+
const control = newMessagePipe(
|
|
89
|
+
{
|
|
90
|
+
send: (bytes) => ws.send(bytes),
|
|
91
|
+
canSend: () => ws.readyState === WS_READY_STATE.OPEN,
|
|
92
|
+
bufferedAmount: () => ws.bufferedAmount ?? 0,
|
|
93
|
+
close: (local) => {
|
|
94
|
+
ws.removeEventListener("message", onMessage);
|
|
95
|
+
ws.removeEventListener("close", onClose);
|
|
96
|
+
if (local) {
|
|
97
|
+
try {
|
|
98
|
+
ws.close();
|
|
99
|
+
} catch {}
|
|
132
100
|
}
|
|
133
|
-
if (life.signal.aborted || ws.readyState !== WS_READY_STATE.OPEN) return; // `signal` says so
|
|
134
|
-
ws.send(bytes);
|
|
135
|
-
},
|
|
136
|
-
async close() {
|
|
137
|
-
listeners.clear();
|
|
138
|
-
end(new Error("webrun-streams-ws: closed locally"));
|
|
139
|
-
try {
|
|
140
|
-
ws.close();
|
|
141
|
-
} catch {}
|
|
142
|
-
},
|
|
143
|
-
get bufferedAmount() {
|
|
144
|
-
return ws.bufferedAmount ?? 0;
|
|
145
|
-
},
|
|
146
|
-
whenDrained() {
|
|
147
|
-
return new Promise<void>((resolve) => {
|
|
148
|
-
const check = (): void => {
|
|
149
|
-
if (life.signal.aborted || (ws.bufferedAmount ?? 0) <= DRAIN_LOW_WATER) resolve();
|
|
150
|
-
else {
|
|
151
|
-
// A peer that stops reading but never closes must not keep Node alive.
|
|
152
|
-
const timer = setTimeout(check, DRAIN_POLL_MS) as { unref?: () => void };
|
|
153
|
-
timer.unref?.();
|
|
154
|
-
}
|
|
155
|
-
};
|
|
156
|
-
check();
|
|
157
|
-
});
|
|
158
101
|
},
|
|
159
102
|
},
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
103
|
+
{
|
|
104
|
+
name: "webrun-streams-ws",
|
|
105
|
+
textAsBytes: true,
|
|
106
|
+
maxFrameBytes: options.maxFrameBytes,
|
|
107
|
+
maxMessageSize: options.maxMessageSize,
|
|
108
|
+
},
|
|
109
|
+
);
|
|
110
|
+
ws.addEventListener("message", onMessage);
|
|
111
|
+
// A failing socket fires `error` and then always `close`: `close` alone ends it.
|
|
112
|
+
ws.addEventListener("close", onClose);
|
|
113
|
+
return control.pipe as WebSocketMessageTarget;
|
|
169
114
|
}
|
|
170
115
|
|
|
171
116
|
export interface OpenWebSocketParams {
|