Typing improvements for io and fixes for websocketclient, and a few others

examples/io/listener/httpserver/httpserver.js

@@ -20,6 +20,20 @@
 
 import Timer from "timer";
 
+const statusReasons = Object.freeze({
+    200: "OK",
+    201: "Created",
+    204: "No Content",
+    301: "Moved Permanently",
+    302: "Found",
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    503: "Service Unavailable",
+});
+
 class Connection {
 	#server;
 	#socket;
@@ -288,7 +302,7 @@ class Connection {
 
 			switch (this.#state) {
 				case "sendResponse":
-					this.#pendingWrite = `HTTP/1.1 ${this.#options.status} FILL_THIS_IN\r\n`;
+					this.#pendingWrite = `HTTP/1.1 ${this.#options.status} ${statusReasons[this.#options.status] ?? ""}\r\n`;
 					this.#pendingWrite = ArrayBuffer.fromString(this.#pendingWrite);
 					this.#writePosition = 0;
 

examples/io/listener/httpserver/options/webpage.js

@@ -21,7 +21,8 @@
 export default {
 	onResponse(response) {
 		response.headers.set("content-length", this.route.msg.byteLength);
-		response.headers.set("content-type", "text/html");
+		response.headers.set("content-type", this.route.contentType ?? "text/html");
+		response.status = this.route.status ?? 200;
 		this.respond(response);
 	},
 	onWritable(count) {

examples/io/tcp/websocket/WebSocket.js

@@ -48,7 +48,7 @@ class WebSocket {
 			keepalive = options.keepalive; 
 			headers = options.headers; 
 		}
-		if (href) {
+		else if (href) {
 			let url = new URL(href);
 			let scheme = url.protocol;
 			let port, config;

examples/io/tcp/websocketclient/manifest_websocketclient.json

@@ -6,13 +6,13 @@
 	],
 	"modules": {
 		"*": [ 
-			"./config",
 			"$(MODULES)/data/logical/*"
 		],
+		"websocketclient/config": "./config",
 		"embedded:network/websocket/client": "./websocketclient"
 	},
 	"preload": [
-		"config",
+		"websocketclient/config",
 		"embedded:network/websocket/client",
 		"logical"
 	]

examples/io/tcp/websocketclient/websocketclient.js

@@ -44,7 +44,7 @@ class WebSocketClient {
 				from: attach,
 				onReadable: count => this.#onReadable(count),
 				onWritable: count => this.#onWritable(count),
-				onError: () => this.#onError()
+				onError: () => this.#onError('ws: unknown socket error')
 			});
 			this.#state = "connected";
 			return;
@@ -71,15 +71,15 @@ class WebSocketClient {
 						port: this.#options.port,
 						onReadable: count => this.#onReadable(count),
 						onWritable: count => this.#onWritable(count),
-						onError: () => this.#onError()
+						onError: () => this.#onError('ws: unknown socket error')
 					});
 				}
 				catch {
-					this.#onError?.();
+					this.#onError?.('ws: unknown socket connect error');
 				}
 			},
 			onError: () => {
-				this.#onError?.();
+				this.#onError?.('dns: unknown resolution error');
 			},
 		});
 	}
@@ -120,17 +120,28 @@ class WebSocketClient {
 		}
 
 		data = data.slice(0);
-		const mask = Uint8Array.of(Math.random() * 256, Math.random() * 256, Math.random() * 256, Math.random() * 256);
-		Logical.xor(data, mask.buffer);
 		const format = this.#socket.format;
 		this.#socket.format = "buffer";
-		if (byteLength < 126) {
-			this.#socket.write(Uint8Array.of(type, byteLength | 0x80, mask[0], mask[1], mask[2], mask[3]));
-			this.#writable -= (6 + byteLength);
-		}
-		else {
-			this.#socket.write(Uint8Array.of(type, 126 | 0x80, byteLength >> 8, byteLength, mask[0], mask[1], mask[2], mask[3]));
-			this.#writable -= (8 + byteLength);
+		if (this.#options.attach) {
+			if (byteLength < 126) {
+				this.#socket.write(Uint8Array.of(type, byteLength));
+				this.#writable -= (2 + byteLength);
+			}
+			else {
+				this.#socket.write(Uint8Array.of(type, 126, byteLength >> 8, byteLength));
+				this.#writable -= (4 + byteLength);
+			}
+		} else {
+			const mask = Uint8Array.of(Math.random() * 256, Math.random() * 256, Math.random() * 256, Math.random() * 256);
+			Logical.xor(data, mask.buffer);
+			if (byteLength < 126) {
+				this.#socket.write(Uint8Array.of(type, byteLength | 0x80, mask[0], mask[1], mask[2], mask[3]));
+				this.#writable -= (6 + byteLength);
+			}
+			else {
+				this.#socket.write(Uint8Array.of(type, 126 | 0x80, byteLength >> 8, byteLength, mask[0], mask[1], mask[2], mask[3]));
+				this.#writable -= (8 + byteLength);
+			}
 		}
 		this.#socket.write(data);
 		this.#socket.format = format;
@@ -161,7 +172,7 @@ class WebSocketClient {
 		if (this.#options.mask) {
 			const mask = this.#options.mask;
 			Logical.xor(data, mask.buffer);
-			if (this.#data) {
+			if (this.#options.length) {
 				switch (count & 3) {
 					case 1:
 						this.#options.mask = Uint8Array.of(mask[1], mask[2], mask[3], mask[0]);
@@ -203,16 +214,16 @@ class WebSocketClient {
 					if ("receiveStatus" === this.#state) {
 						let status = this.#line.split(" ");
 						if (status.length < 3)
-							return void this.#onError();
+							return void this.#onError('ws: http upgrade error (http status len < 3)');
 						status = parseInt(status[1]);
 						if (101 !== status)
-							return void this.#onError();
+							return void this.#onError(`ws: http upgrade error (expected status 101, got ${status})`);
 						this.#state = "receiveHeader";
 					}
 					else if ("\r\n" === this.#line) {
 						// done
 						if (7 !== this.#options.flags)
-							return void this.#onError();
+							return void this.#onError(`ws: http upgrade error (insufficient header received)`);
 						this.#state = "connected";
 						delete this.#options.flags;
 						this.#socket.format = "buffer";
@@ -257,17 +268,17 @@ class WebSocketClient {
 						count--;
 
 						if (tag & 0x70)
-							return void this.#onError();
+							return void this.#onError('ws: unsupported reserved bits');
 
 						tag &= 0x0F;
-						if (1 === tag & 0x0F)
+						if (1 === tag)
 							options.binary = false;
 						else if (2 === tag)
 							options.binary = true;
 						else if (8 & tag)
 							options.control = true;
 						else if (tag)
-							return void this.#onError();
+							return void this.#onError('ws: unknown opcode (${tag})');
 						continue;
 					}
 					if (undefined === options.length) {
@@ -290,7 +301,7 @@ class WebSocketClient {
 						continue;
 					}
 					if (options.mask && options.mask.length < 4) {
-						//@@ it is an error for client to receieve a mask. this code applies to future server. client should fail here.
+						//@@ it is an error for client to receieve a mask. client should fail here.
 						options.mask.push(this.#socket.read());
 						count--;
 						if (4 !== options.mask.length)
@@ -317,6 +328,9 @@ class WebSocketClient {
 							return;
 
 						const opcode = options.tag & 0x0F;
+						if (options.mask) {
+							Logical.xor(control, options.mask.buffer);
+						}
 						try {
 							this.#options.onControl?.call(this, opcode, control.buffer);
 						}
@@ -354,7 +368,7 @@ class WebSocketClient {
 						else if (10 === opcode)	// pong
 							;
 						else
-							return void this.#onError();
+							return void this.#onError(`ws: unknown control opcode ${opcode}`);
 
 
 						delete options.tag;
@@ -464,12 +478,12 @@ class WebSocketClient {
 				break;
 		}
 	}
-	#onError() {
+	#onError(error) {
 		this.close();
 		if (this.#options.close)
 			this.#options.onClose?.call(this);
 		else
-			this.#options.onError?.call(this);
+			this.#options.onError?.call(this, error);
 	}
 
 	static text = 1;

examples/io/tcp/websocketsclient/config.js

@@ -1,6 +1,5 @@
 import "system"		// system initializes globalThis.device. this ensures it runs before this module.
 
-import TCP from "embedded:io/socket/tcp";
 import UDP from "embedded:io/socket/udp";
 import Resolver from "embedded:network/dns/resolver/udp";
 import TLSSocket from "embedded:io/socket/tcp/tls";

examples/manifest_typings.json

@@ -33,17 +33,23 @@
 		"embedded:io/socket/*": [
 			"$(TYPINGS)/embedded_io/socket/*"
 		],
+		"embedded:io/socket/tcp/*": [
+			"$(TYPINGS)/embedded_io/socket/tcp/*"
+		],
 		"embedded:network/http/*": [
 			"$(TYPINGS)/embedded_network/http/*"
 		],
+		"embedded:network/http/server/options/*": [
+			"$(TYPINGS)/embedded_network/http/server/options/*"
+		],
 		"embedded:network/mqtt/*": [
 			"$(TYPINGS)/embedded_network/mqtt/*"
 		],
 		"embedded:network/dns/resolver/*": [
 			"$(TYPINGS)/embedded_network/dns/resolver/*"
 		],
-		"embedded:network/*": [
-			"$(TYPINGS)/embedded_network/*"
+		"embedded:network/websocket/*": [
+			"$(TYPINGS)/embedded_network/websocket/*"
 		],
 		"mqtt/js": [
 			"$(TYPINGS)/mqtt/js"

typings/embedded_io/socket/listener.d.ts

@@ -19,19 +19,25 @@
 */
 
 declare module "embedded:io/socket/listener" {
-  import TCP from "embedded:io/socket/tcp"
+  import type TCP from "embedded:io/socket/tcp";
+
+  export interface ListenerOptions {
+    port?: number;
+    address?: string;
+    onReadable?: (this: Listener, bytes: number) => void;
+    format?: "socket/tcp";
+  }
+
+  export type ListenerDevice = ListenerOptions & { io: typeof Listener };
+
   class Listener {
-    constructor(options: {
-      port?: number;
-      address?: string;
-      onReadable?: (this: Listener, requests: number) => void;
-      format?: "socket/tcp";
-      target?: any;
-    })
+    constructor(options: ListenerOptions)
     read(): TCP | undefined
     get format(): "socket/tcp"
     set format(value: "socket/tcp")
+
     readonly port: number;
   }
+
   export default Listener;
 }

typings/embedded_io/socket/tcp.d.ts

@@ -1,51 +1,53 @@
 /*
-* Copyright (c) 2022 Shinya Ishikawa
-*
-*   This file is part of the Moddable SDK Tools.
-*
-*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
-*   it under the terms of the GNU General Public License as published by
-*   the Free Software Foundation, either version 3 of the License, or
-*   (at your option) any later version.
-*
-*   The Moddable SDK Tools is distributed in the hope that it will be useful,
-*   but WITHOUT ANY WARRANTY; without even the implied warranty of
-*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*   GNU General Public License for more details.
-*
-*   You should have received a copy of the GNU General Public License
-*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
-
+ * Copyright (c) 2022 Shinya Ishikawa
+ *
+ *   This file is part of the Moddable SDK Tools.
+ *
+ *   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   The Moddable SDK Tools is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
 declare module "embedded:io/socket/tcp" {
-  import type { Buffer } from "embedded:io/_common";
-  export type Options = ((({
-    address: string;
-  } | {
-    host: string;
-  }) & {
-    port: number;
-  }) | {
-    from: TCP;
-  }) & {
-    nodelay?: boolean;
-    onReadable?: (this: TCP, bytes: number) => void;
-    onWritable?: (this: TCP, bytes: number) => void;
-    onError?: (this: TCP) => void;
-    format?: "number" | "buffer";
-    target?: any;
-  };
-
-  export default class TCP {
-    constructor(options: Options)
-    readonly remoteAddress: string | undefined;
-    readonly remotePort: number | undefined;
-    read(byteLength?: number): number | ArrayBuffer;
-    read(buffer: Buffer): void;
-    write(value: number | Buffer): void;
-    close(): void;
-    get format(): "number" | "buffer"
-    set format(value: "number" | "buffer")
-  }
+	import type { Buffer } from "embedded:io/_common";
+	import type UDP from "embedded:io/socket/udp";
+
+	export type TCPOptions = ((
+		{
+			address: string;
+			port: number;
+		} | {
+			from: TCP;
+		}) & {
+			nodelay?: boolean;
+			onReadable?: (this: TCP, bytes: number) => void;
+			onWritable?: (this: TCP, bytes: number) => void;
+			onError?: (this: TCP) => void;
+			format?: "number" | "buffer";
+		}
+	);
+
+	export type TCPDevice = TCPOptions & { io: typeof UDP };
+
+	export default class TCP {
+		constructor(options: TCPOptions);
+		readonly remoteAddress: string | undefined;
+		readonly remotePort: number | undefined;
+		read(): number;
+		read(byteLength: number): ArrayBuffer;
+		read(buffer: Buffer): void;
+		write(value: number | Buffer): void;
+		close(): void;
+		get format(): "number" | "buffer";
+		set format(value: "number" | "buffer");
+	}
 }