socket-function 1.1.0 → 1.1.2

package/index.d.ts

@@ -537,10 +537,10 @@ declare module "socket-function/src/Zip" {
         static gzipSync(buffer: Buffer, level?: number): Buffer;
         static gunzip(buffer: Buffer): MaybePromise<Buffer>;
         static gunzipAsyncBase(buffer: Buffer): Promise<Buffer>;
-        static gunzipUntracked(buffer: Buffer): Promise<Buffer>;
         static gunzipSync(buffer: Buffer): Buffer;
-        private static gunzipUntrackedSync;
         static gunzipBatch(buffers: Buffer[]): Promise<Buffer[]>;
+        static gunzipUntracked(buffer: Buffer): MaybePromise<Buffer>;
+        private static gunzipUntrackedSync;
     }
 
 }

package/package.json

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

package/src/Zip.d.ts

@@ -6,8 +6,8 @@ export declare class Zip {
     static gzipSync(buffer: Buffer, level?: number): Buffer;
     static gunzip(buffer: Buffer): MaybePromise<Buffer>;
     static gunzipAsyncBase(buffer: Buffer): Promise<Buffer>;
-    static gunzipUntracked(buffer: Buffer): Promise<Buffer>;
     static gunzipSync(buffer: Buffer): Buffer;
-    private static gunzipUntrackedSync;
     static gunzipBatch(buffers: Buffer[]): Promise<Buffer[]>;
+    static gunzipUntracked(buffer: Buffer): MaybePromise<Buffer>;
+    private static gunzipUntrackedSync;
 }

package/src/Zip.ts

@@ -8,10 +8,15 @@ import { MaybePromise } from "./types";
 setFlag(require, "pako", "allowclient", true);
 
 const SYNC_THRESHOLD_BYTES = 100_000_000;
+const ZIP_SYNC_THRESHOLD_BYTES = 10_000_000;
 
+// IMPORTANT! If this is slow, add a LZ4 version, which uses lz4-wasm-nodejs. This should be about 10X faster in both dcompression and decompression, only using 50% more space (which isn't great, but... if it is lagging the main thread it might be worth it).
 export class Zip {
     @measureFnc
     public static async gzip(buffer: Buffer, level?: number): Promise<Buffer> {
+        if (buffer.length < ZIP_SYNC_THRESHOLD_BYTES) {
+            return this.gzipSync(buffer, level);
+        }
         if (isNode()) {
             return new Promise((resolve, reject) => {
                 zlib.gzip(buffer, { level }, (err: any, result: Buffer) => {
@@ -26,17 +31,46 @@ export class Zip {
     }
     @measureFnc
     public static gzipSync(buffer: Buffer, level?: number): Buffer {
-        if (isNode()) {
+        if (isNode() && buffer.length < ZIP_SYNC_THRESHOLD_BYTES) {
             return Buffer.from(zlib.gzipSync(buffer, { level }));
         }
-        return Buffer.from(pako.deflate(buffer));
+        return Buffer.from(pako.gzip(buffer));
     }
+
+    @measureFnc
     public static gunzip(buffer: Buffer): MaybePromise<Buffer> {
+        return this.gunzipUntracked(buffer);
+    }
+    @measureFnc
+    public static async gunzipAsyncBase(buffer: Buffer): Promise<Buffer> {
+        return this.gunzipUntracked(buffer);
+    }
+
+    @measureFnc
+    public static gunzipSync(buffer: Buffer): Buffer {
+        return this.gunzipUntrackedSync(buffer);
+    }
+
+    @measureFnc
+    public static async gunzipBatch(buffers: Buffer[]): Promise<Buffer[]> {
+        let time = Date.now();
+        buffers = await Promise.all(buffers.map(x => {
+            return this.gunzipUntracked(x);
+        }));
+        time = Date.now() - time;
+        // let totalSize = buffers.reduce((acc, buffer) => acc + buffer.length, 0);
+        //console.log(`Gunzip ${formatNumber(totalSize)}B at ${formatNumber(totalSize / time * 1000)}B/s`);
+        return buffers;
+    }
+
+
+
+    public static gunzipUntracked(buffer: Buffer): MaybePromise<Buffer> {
         // Switch to the synchronous version if the buffer is small. This is a lot faster in Node.js and clientside.
         //  - On tests of random small amounts of data, this seems to be up to 7X faster (on node). However, on non-random data, on the actual data we're using, it seems to be almost 50 times faster. So... definitely worth it...
         if (buffer.length < SYNC_THRESHOLD_BYTES) {
             let time = Date.now();
-            let result = Zip.gunzipSync(buffer);
+            let result = Zip.gunzipUntrackedSync(buffer);
             let duration = Date.now() - time;
             if (duration > 50) {
                 // Wait, so we don't lock up the main thread. And if we already wait it 50ms, then waiting for one frame is marginal, even client-side. 
@@ -47,49 +81,18 @@ export class Zip {
             }
             return result;
         }
-        return Zip.gunzipAsyncBase(buffer);
-    }
-    @measureFnc
-    public static async gunzipAsyncBase(buffer: Buffer): Promise<Buffer> {
-        return Zip.gunzipUntracked(buffer);
-    }
-    // A base function, so we can avoid instrumentation for batch calls
-    public static async gunzipUntracked(buffer: Buffer): Promise<Buffer> {
         if (isNode()) {
-            return await new Promise<Buffer>((resolve, reject) => {
-                zlib.gunzip(buffer, (err: any, result: Buffer) => {
-                    if (err) reject(err);
-                    else resolve(result);
-                });
-            });
+            return doStream(new DecompressionStream("gzip"), buffer);
+        } else {
+            return Zip.gunzipUntrackedSync(buffer);
         }
-        return await doStream(new DecompressionStream("gzip"), buffer);
     }
 
-    @measureFnc
-    public static gunzipSync(buffer: Buffer): Buffer {
-        return this.gunzipUntrackedSync(buffer);
-    }
     private static gunzipUntrackedSync(buffer: Buffer): Buffer {
-        if (isNode()) {
+        if (isNode() && buffer.length < ZIP_SYNC_THRESHOLD_BYTES) {
             return Buffer.from(zlib.gunzipSync(buffer));
         }
-        return Buffer.from(pako.inflate(buffer));
-    }
-
-    @measureFnc
-    public static async gunzipBatch(buffers: Buffer[]): Promise<Buffer[]> {
-        let time = Date.now();
-        buffers = await Promise.all(buffers.map(x => {
-            if (x.length < SYNC_THRESHOLD_BYTES) {
-                return this.gunzipUntrackedSync(x);
-            }
-            return this.gunzipUntracked(x);
-        }));
-        time = Date.now() - time;
-        let totalSize = buffers.reduce((acc, buffer) => acc + buffer.length, 0);
-        //console.log(`Gunzip ${formatNumber(totalSize)}B at ${formatNumber(totalSize / time * 1000)}B/s`);
-        return buffers;
+        return Buffer.from(pako.ungzip(buffer));
     }
 }
 

package/src/callManager.ts

@@ -87,12 +87,8 @@ export function registerClass(classGuid: string, controller: SocketExposedInterf
     }
 
     if (!config?.noFunctionMeasure) {
-        let keys = new Set([
-            ...Object.keys(controller),
-            ...Object.getOwnPropertyNames(controller.__proto__ || {}),
-        ]);
         let niceClassName = controller.constructor.name || classGuid;
-        for (let functionName of keys) {
+        for (let functionName of Object.keys(shape)) {
             if (functionName === "constructor") continue;
             let fnc = controller[functionName];
             if (typeof fnc !== "function") continue;

package/src/nodeCache.ts

@@ -61,7 +61,7 @@ export function getNodeIdDomainMaybeUndefined(nodeId: string): string | undefine
     if (!location) {
         return undefined;
     }
-    return new URL(location.address).hostname.split(".").slice(-2).join(".");
+    return new URL("https://" + location.address).hostname.split(".").slice(-2).join(".");
 }
 
 // NOTE: CallFactory turns into an actual CallFactory when registerNodeClient is called