socket-function 1.1.19 → 1.1.20

package/index.d.ts

@@ -1265,16 +1265,11 @@ declare module "socket-function/src/profiling/tcpLagProxy" {
 }
 
 declare module "socket-function/src/promiseRace" {
-    export declare class PromiseLessLeaky<T> extends Promise<T> {
-        constructor(executor: ((resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) | undefined);
-    }
-    /** A promise race function which doesn't leak, unlike Promise.race
-
-        See https://github.com/nodejs/node/issues/17469
-        See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
-
+    /** Fixed Promise.race, which doesn't leak promises values. Promises still leak the Promise object themselves, but a Promise is < 100 bytes, where as the promise VALUE might be arbitrarily large.
      */
-    export declare function promiseRace<T extends readonly unknown[] | []>(promises: T): Promise<Awaited<T[number]>>;
+    export declare function PromiseRace<T extends any[]>(promises: {
+        [K in keyof T]: Promise<T[K]>;
+    }): Promise<T[number]>;
 
 }
 

package/package.json

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

package/src/promiseRace.d.ts

@@ -1,10 +1,5 @@
-export declare class PromiseLessLeaky<T> extends Promise<T> {
-    constructor(executor: ((resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) | undefined);
-}
-/** A promise race function which doesn't leak, unlike Promise.race
-
-    See https://github.com/nodejs/node/issues/17469
-    See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
-
+/** Fixed Promise.race, which doesn't leak promises values. Promises still leak the Promise object themselves, but a Promise is < 100 bytes, where as the promise VALUE might be arbitrarily large.
  */
-export declare function promiseRace<T extends readonly unknown[] | []>(promises: T): Promise<Awaited<T[number]>>;
+export declare function PromiseRace<T extends any[]>(promises: {
+    [K in keyof T]: Promise<T[K]>;
+}): Promise<T[number]>;

package/src/promiseRace.ts

@@ -1,184 +1,110 @@
-
-// Less leaky promise.
-//  See https://github.com/nodejs/node/issues/17469
-//  See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
-// Basically, make resolve/reject weakly reference the Promise, so that
-//  resolved promises aren't kept alive. The `resolve` function is still leaked
-//  itself, but at least it doesn't leak the underlying data.
-export class PromiseLessLeaky<T> extends Promise<T> {
-    constructor(executor: ((
-        resolve: (value: T | PromiseLike<T>) => void,
-        reject: (reason?: any) => void
-    ) => void) | undefined
-    ) {
-        super(((
-            resolve: ((value: T | PromiseLike<T>) => void) | undefined,
-            reject: ((reason?: any) => void) | undefined
-        ) => {
-            executor?.(
-                function PromiseLessLeakyResolved(value) {
-                    let callback = resolve;
-                    resolve = undefined;
-                    reject = undefined;
-                    if (callback) {
-                        callback(value);
-                    }
-                },
-                function PromiseLessLeakyRejected(value) {
-                    let callback = reject;
-                    resolve = undefined;
-                    reject = undefined;
-                    if (callback) {
-                        callback(value);
-                    }
-                }
-            );
-            executor = undefined;
-        }));
-    }
-}
-function remove<T>(list: T[], value: T) {
-    let index = list.indexOf(value);
-    if (index >= 0) {
-        list.splice(index, 1);
-    }
-}
-const promiseCallbacks = new WeakMap<object, {
-    onResolve: ((value: any) => void)[];
-    onReject: ((value: any) => void)[];
-    onFinally: (() => void)[];
-}>();
-/** A promise race function which doesn't leak, unlike Promise.race
-
-    See https://github.com/nodejs/node/issues/17469
-    See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
-
+/** Fixed Promise.race, which doesn't leak promises values. Promises still leak the Promise object themselves, but a Promise is < 100 bytes, where as the promise VALUE might be arbitrarily large.
  */
-export function promiseRace<T extends readonly unknown[] | []>(promises: T): Promise<Awaited<T[number]>> {
-    return new PromiseLessLeaky((resolve, reject) => {
-        let actualPromises: Promise<unknown>[] = [];
+export function PromiseRace<T extends any[]>(promises: { [K in keyof T]: Promise<T[K]> }): Promise<T[number]> {
+    return new PromiseLessLeaky((resolve: any, reject: any) => {
         function onFinally() {
-            for (let promise of actualPromises) {
-                let callbackObj = promiseCallbacks.get(promise);
-                if (!callbackObj) continue;
-                remove(callbackObj.onResolve, resolve);
-                remove(callbackObj.onReject, reject);
-                remove(callbackObj.onFinally, onFinally);
+            for (let promise of promises) {
+                if (promise && typeof promise === "object" && promise instanceof Promise) {
+                    let callbackObj = promiseCallbacks.get(promise);
+                    if (!callbackObj) continue;
+                    remove(callbackObj.onResolve, resolve);
+                    remove(callbackObj.onReject, reject);
+                    remove(callbackObj.onFinally, onFinally);
+                }
             }
         }
         for (let promise of promises) {
-            // If not a thenable, use Promise.resolve to make it a promise, and use the build in functions, as it won't hold a reference because it will resolve immediately.
-            if (!(promise && (typeof promise === "object" || typeof promise === "function") && ("then" in promise))) {
-                Promise.resolve(promise).then(resolve as any, reject);
+            // NOTE: This "if" statement greatly reduce leaks, although it might
+            //  reduce speed as well?
+            if (promise && typeof promise === "object" && promise instanceof Promise) {
+                let callbackObj = promiseCallbacks.get(promise);
+                let firstSetup = false;
+                if (!callbackObj) {
+                    firstSetup = true;
+                    callbackObj = {
+                        onResolve: [],
+                        onReject: [],
+                        onFinally: [],
+                    };
+                    promiseCallbacks.set(promise, callbackObj);
+                }
+                callbackObj.onResolve.push(resolve);
+                callbackObj.onReject.push(reject);
+                callbackObj.onFinally.push(onFinally);
+                // We need to delay this in case we're immediately triggered, because we're already resolved. 
+                if (firstSetup) {
+                    connectPromiseToCallbackObj(promise, callbackObj);
+                }
                 continue;
             }
-            actualPromises.push(promise as Promise<unknown>);
-            let callbackObj = promiseCallbacks.get(promise);
-            if (!callbackObj) {
-                callbackObj = {
-                    onResolve: [],
-                    onReject: [],
-                    onFinally: [],
-                };
-                promiseCallbacks.set(promise, callbackObj);
-                connectPromiseToCallbackObj(Promise.resolve(promise), callbackObj);
-            }
-            callbackObj.onResolve.push(resolve);
-            callbackObj.onReject.push(reject);
-            callbackObj.onFinally.push(onFinally);
+
+            void Promise.resolve(promise).then(resolve, reject);
         }
     }) as any;
-};
+}
 
-function connectPromiseToCallbackObj(promise: Promise<any>, callbackObj: {
-    onResolve: ((value: any) => void)[];
-    onReject: ((value: any) => void)[];
-    onFinally: (() => void)[];
-}) {
+function remove(list: any, value: any) {
+    let index = list.indexOf(value);
+    if (index >= 0) {
+        list.splice(index, 1);
+    }
+}
+const promiseCallbacks = new WeakMap();
+
+function connectPromiseToCallbackObj(promise: any, callbackObj: any) {
     // NOTE: If the promise stays alive forever... this will leak callbackObj. BUT,
     //  it is only called once per promise, ever, so... the leak isn't so bad!
     promise.then(
-        value => {
-            for (let fnc of callbackObj.onResolve) {
+        (value: any) => {
+            // We need to delete the callback lists once on finally happens. Because we only connect to the promise once, And so it'll only trigger us once. So removing it is the only way to get it to trigger us again if someone subscribes to a finished promise. 
+            promiseCallbacks.delete(promise);
+            for (let fnc of callbackObj.onResolve.slice()) {
                 try { fnc(value); } finally { }
             }
         },
-        value => {
-            for (let fnc of callbackObj.onReject) {
+        (value: any) => {
+            promiseCallbacks.delete(promise);
+            for (let fnc of callbackObj.onReject.slice()) {
                 try { fnc(value); } finally { }
             }
         }
     ).finally(() => {
-        for (let fnc of callbackObj.onFinally) {
+        for (let fnc of callbackObj.onFinally.slice()) {
             try { fnc(); } finally { }
         }
     });
 }
 
 
-async function main() {
-    const { formatTime } = await import("./formatting/format");
-    const os = require("os");
-    let count = 0;
-
-    // @ts-ignore
-    function createNamedObject(name) {
-        return eval(`(class ${name} {  
-            memory = (() => {
-                // let memory = new Float64Array(1024 * 1024);
-                // for (let i = 0; i < memory.length; i++) {
-                //     memory[i] = Math.random();
-                // }
-                // return memory;
-            })();
-        })`);
-    }
-    let LeakedTag = createNamedObject("LeakedTag");
-    let LeakedTag2 = createNamedObject("LeakedTag2");
-    function createPromiseObj<T>() {
-        let resolve!: ((value: T | PromiseLike<T>) => void);
-        let reject!: ((reason?: any) => void);
-        let promise = new Promise<T>((_resolve, _reject) => {
-            resolve = _resolve;
-            reject = _reject;
-        });
-        void promise.finally(() => {
-            (globalThis as any)["keepAliveValueTest"] = ((globalThis as any)["keepAliveValueTest"] || 0) + 1;
+// Less leaky promise.
+//  See https://github.com/nodejs/node/issues/17469
+//  See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
+// Basically, make resolve/reject weakly reference the Promise, so that
+//  resolved promises aren't kept alive. The `resolve` function is still leaked
+//  itself, but at least it doesn't leak the underlying data.
+// IMPORTANT! This still leaks! So... maybe don't even use Promise.race?
+class PromiseLessLeaky extends Promise<any> {
+    constructor(executor: any) {
+        super((resolve, reject) => {
+            executor(
+                function PromiseLessLeakyResolved(value: any) {
+                    let callback = resolve;
+                    resolve = undefined as any;
+                    reject = undefined as any;
+                    if (callback) {
+                        callback(value);
+                    }
+                },
+                function PromiseLessLeakyRejected(value: any) {
+                    let callback = reject;
+                    resolve = undefined as any;
+                    reject = undefined as any;
+                    if (callback) {
+                        callback(value);
+                    }
+                }
+            );
+            executor = undefined;
         });
-        return {
-            promise,
-            resolve,
-            reject,
-        };
-    }
-
-    let exitPromiseObj = createPromiseObj<void>();
-    setTimeout(() => {
-        exitPromiseObj.resolve(undefined);
-    }, 1000 * 60 * 60);
-
-    async function doWork() {
-        return new LeakedTag();
-    }
-
-    // @ts-ignore
-    let createRace: (promises: Promise<any>[]) => Promise<any>;
-
-    // Leaks (you can see LeakedTag in the heap dump, and also usage goes to the moon)
-    //createRace = promises => Promise.race(promises);
-
-    // Doesn't leak
-    createRace = promises => promiseRace(promises);
-
-    let time = Date.now();
-
-    while (true) {
-        await createRace([doWork(), exitPromiseObj.promise]);
-        count++;
-        if (count % 100000 === 0) {
-            let duration = Date.now() - time;
-            console.log(`Did ${count} test runs, used memory is at ${(process.memoryUsage().heapUsed)}, time per count is ${formatTime(duration / count)}`);
-        }
     }
 }
-//void main();