socket-function 0.159.0 → 0.161.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.159.0",
+	"version": "0.161.0",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/require/require.d.ts

@@ -1,4 +1,4 @@
-/// <reference path="../index.d.ts" />
+/// <reference path="../src/src.d.ts" />
 declare global {
     var onProgressHandler: undefined | ((progress: {
         type: string;

package/require/require.ts

@@ -1,4 +1,4 @@
-/// <reference path="../index.d.ts" />
+/// <reference path="../src/src.d.ts" />
 
 import { GetModulesArgs } from "./RequireController";
 

package/src/src.d.ts

@@ -0,0 +1,43 @@
+/// <reference path="./node_modules/typenode/index.d.ts" />
+
+export { };
+
+declare global {
+    namespace NodeJS {
+        interface Module {
+            original?: SerializedModule;
+        }
+    }
+    interface SerializedModule {
+        originalId: string;
+        filename: string;
+        // If a module is not allowed clientside it is likely requests will be empty,
+        //  to save effort parsing requests for modules that only exist to give better
+        //  error messages.
+        requests: {
+            // request => resolvedPath
+            [request: string]: string;
+        };
+        asyncRequests: { [request: string]: true };
+        // NOTE: IF !allowclient && !serveronly, it might just mean we didn't add allowclient
+        //  to the module yet. BUT, if serveronly, then we know for sure we don't want it client.
+        //  So the messages and behavior will be different.
+        allowclient?: boolean;
+        serveronly?: boolean;
+        // Just for errors mostly
+        alwayssend?: boolean;
+
+        /** Only set if allowclient. */
+        source?: string;
+
+        seqNum: number;
+
+        size?: number;
+        version?: number;
+
+        flags?: {
+            [flag: string]: true;
+        };
+    }
+
+}

package/src/webSocketServer.ts

@@ -255,6 +255,9 @@ export async function startSocketServer(
             //  we pipe. This should be very efficient, as pipe has insane throughput
             //  (100s of MB/s, easily, even on a terrible machine).
             socket.once("data", buffer => {
+                if (typeof buffer === "string") {
+                    buffer = Buffer.from(buffer);
+                }
                 buffers.push(buffer);
                 let result = handleTLSHello(Buffer.concat(buffers), buffers.length);
                 if (result === "more") {