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",
+});
+
 const more = Object.freeze({more: true});
 
 class Connection {
@@ -282,7 +296,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

@@ -45,6 +45,7 @@ export default {
 		else
 			throw new Error("unsupported data type");
 		response.headers.set("content-type", route.contentType ?? "text/html");
+		response.status = this.route.status ?? 200;
 		this.respond(response);
 	},
 	onWritable(count) {

examples/io/tcp/websocket/WebSocket.js

@@ -310,6 +310,4 @@ class WebSocket {
 	}
 }
 
-export default WebSocket;
-
-
+export default WebSocket;

examples/io/tcp/websocketclient/config.js

@@ -28,4 +28,3 @@ globalThis.device = Object.freeze({
 		},
 	},
 }, true);
-

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

@@ -402,6 +402,9 @@ class WebSocketClient {
 							return;
 
 						const opcode = options.tag & 0x0F;
+						if (options.mask) {
+							Logical.xor(control.buffer, options.mask.buffer);
+						}
 						try {
 							this.#options.onControl?.call(this, opcode, control.buffer);
 							if (!this.#socket)
@@ -587,4 +590,4 @@ class WebSocketClient {
 	static pong = 10;
 }
 
-export default WebSocketClient;
+export default WebSocketClient;

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";
@@ -29,4 +28,4 @@ globalThis.device = Object.freeze({
 			}
 		},
 	},
-}, true);
+}, true);

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 | undefined;
+		read(buffer: Buffer): void;
+		write(value: number | Buffer): void;
+		close(): void;
+		get format(): "number" | "buffer";
+		set format(value: "number" | "buffer");
+	}
 }

typings/embedded_io/socket/tcp/tls.d.ts

@@ -0,0 +1,27 @@
+declare module "embedded:io/socket/tcp/tls" {
+	import TCP, { TCPOptions } from "embedded:io/socket/tcp";
+	import UDP from "embedded:io/socket/udp";
+
+	export type SSLSessionOptions = {
+		protocolVersion?: number;
+		serverName?: string;
+		applicationLayerProtocolNegotiation?: string;
+		trace?: number;
+		cache?: boolean;
+		tls_server_name?: string;
+		client_auth?: {
+			cipherSuites: string[];
+			subjectDN: string;
+		};
+	};
+
+	export type TLSOptions = TCPOptions & {
+		host: string;
+		secure: SSLSessionOptions;
+	};
+	export type TLSDevice = TCPOptions & { io: typeof UDP };
+
+	export default class TLSSocket extends TCP {
+		constructor(options: TLSOptions);
+	}
+}

typings/embedded_io/socket/udp.d.ts

@@ -20,27 +20,34 @@
 
 declare module "embedded:io/socket/udp" {
   import type { Buffer } from "embedded:io/_common";
+
+  interface UDPOptionsBase {
+    port?: number;
+    address?: string;
+    onReadable?: (this: UDP, packets: number) => void;
+    onError?: () => void;
+    format?: "buffer";
+  }
+
+  interface UDPMulticastOptions {
+    multicast: string;
+    timeToLive: number;
+  }
+
+  export type UDPOptions = UDPOptionsBase & ({} | UDPMulticastOptions);
+
+  export type UDPDevice = UDPOptions & { io: typeof UDP };
+
   class UDP {
-    constructor(options: {
-      port?: number;
-      address?: string;
-      onReadable?: (this: UDP, packets: number) => void;
-      onError?: () => void;
-      format?: "buffer";
-      target?: any;
-    } & ({} | {
-      multicast: string;
-      timeToLive: number;
-    }))
+    constructor(options: UDPOptions)
     write(buffer: Buffer, address: string, port: number): void;
     read(): ArrayBuffer & {
       address: string;
       port: number;
     };
-    read(buffer: Buffer);
     get format(): "buffer"
     set format(value: "buffer")
   }
-
-  export default UDP
+  
+  export default UDP;
 }

typings/embedded_network/dns/resolver/udp.d.ts

@@ -19,19 +19,27 @@
 */
 
 declare module "embedded:network/dns/resolver/udp" {
+  import type { UDPDevice } from 'embedded:io/socket/udp';
 
-  interface Options {
-    host: string
-    onResolved: ((host:string, address:any) => null)
-    onError: ((host:string) => null)
+  export interface DNSUDPOptions {
+    http?: never;
+    servers: string[];
+    socket: UDPDevice;
   }
 
-  class Resolver {
-    constructor(options: Record<string, any>)
-    close(): void
-    resolve(options: Options): void
+  export interface DNSUDPResolveOptions {
+    host: string;
+    onResolved: ((host:string, address:any) => null);
+    onError: ((host:string) => null);
+  }
 
+  export type DNSUDPDevice = DNSUDPOptions & { io: typeof Resolver };
+
+  class Resolver {
+    constructor(options: DNSUDPOptions);
+    close(): void;
+    resolve(options: DNSUDPResolveOptions): void;
   }
 
-  export default Resolver
+  export default Resolver;
 }