socket-function 1.0.6 → 1.1.1

package/index.d.ts

@@ -529,7 +529,6 @@ declare module "socket-function/src/JSONLACKS/JSONLACKS.generated.js" {
 }
 
 declare module "socket-function/src/Zip" {
-    /// <reference path="../index.d.ts" />
     /// <reference types="node" />
     /// <reference types="node" />
     import { MaybePromise } from "socket-function/src/types";
@@ -538,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.0.6",
+	"version": "1.1.1",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/Zip.d.ts

@@ -1,14 +1,13 @@
-/// <reference path="../index.d.ts" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { MaybePromise } from "socket-function/src/types";
+import { MaybePromise } from "./types";
 export declare class Zip {
     static gzip(buffer: Buffer, level?: number): Promise<Buffer>;
     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

@@ -1,17 +1,22 @@
-import { isNode } from "socket-function/src/misc";
-import { measureFnc } from "socket-function/src/profiling/measure";
+import { isNode } from "./misc";
+import { measureFnc } from "./profiling/measure";
 import zlib from "zlib";
 import * as pako from "pako";
 
-import { setFlag } from "socket-function/require/compileFlags";
-import { MaybePromise } from "socket-function/src/types";
+import { setFlag } from "../require/compileFlags";
+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 ever profiles as being slow, we should switch to a wasm implementation of L4Z. For our highly repetitive data, it's almost as efficient in terms of size, and it should be significantly more efficient in terms of time.
 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;