socket-function 0.8.37 → 0.8.38

package/src/batching.ts

@@ -0,0 +1,94 @@
+import { isNode } from "./misc";
+import { measureWrap } from "./profiling/measure";
+
+/*
+    "numbers" use setTimeout
+    "afterpromises" uses a microtask, see https://developer.mozilla.org/en-US/docs/Web/API/HTML_DOM_API/Microtask_guide
+    "afterio" uses setImmediate, which will be after all pending and all created promises
+        (in the browser it is likely setImmediate will be shimmed with setTimeout)
+    "immediate" uses setImmediate, but if not available uses "afterpromises"
+        - The ensures a prompt return, without resorting to setTimeout in the browser (which will cause
+            the callback to be delayed a frame).
+*/
+export type DelayType = number | "afterio" | "immediate" | "afterpromises";
+export function delay(delayTime: DelayType): Promise<void> {
+    if (delayTime === "afterio") {
+        return new Promise<void>(resolve => setImmediate(resolve));
+    } else if (delayTime === "afterpromises") {
+        // NOTE: We use a promise here as it might be a bit easier to debug than queueMicrotask.
+        //  It is equivalent though...
+        return Promise.resolve();
+    } else if (delayTime === "immediate") {
+        if (isNode()) {
+            return new Promise<void>(resolve => setImmediate(resolve));
+        } else {
+            return delay("afterpromises");
+        }
+    } else {
+        return new Promise<void>(resolve => setTimeout(resolve, delayTime));
+    }
+}
+
+export function batchFunction<Arg, Result = void>(
+    config: {
+        delay: DelayType;
+        name?: string;
+    },
+    fnc: (arg: Arg[]) => (Promise<Result> | Result)
+): (arg: Arg) => Promise<Result> {
+    fnc = measureWrap(fnc, config.name);
+
+    let prevPromise: Promise<Result> | undefined;
+    let batched: {
+        args: Arg[];
+        promise: Promise<Result>;
+    } | undefined;
+    return async arg => {
+        if (!batched) {
+            await prevPromise;
+        }
+        if (batched) {
+            batched.args.push(arg);
+            return await batched.promise;
+        }
+
+        let args: Arg[] = [arg];
+        let promise = Promise.resolve().then(async () => {
+            await delay(config.delay);
+            // After we call the function, we can no longer accept args
+            batched = undefined;
+            return await fnc(args);
+        });
+        batched = {
+            args,
+            promise,
+        };
+        // We need to prevent new calls from starting when the previous call can no longer accept
+        //  args, BUT, before it has finished.
+        prevPromise = batched.promise;
+
+        return await promise;
+    };
+}
+
+export function runInSerial<T extends (...args: any[]) => Promise<any>>(fnc: T): T {
+    let updateQueue: (() => void)[] = [];
+
+    return (async (...args: any[]) => {
+        const queueWasEmpty = updateQueue.length === 0;
+        if (!queueWasEmpty) {
+            // Wait for the previous promise to resolve
+            await new Promise<void>(resolve => updateQueue.push(resolve));
+        }
+        updateQueue.push(() => { });
+
+        try {
+            return await fnc(...args);
+        } finally {
+            // Pop ourself off
+            updateQueue.shift();
+            // Resolve the next promise
+            updateQueue[0]?.();
+        }
+    }) as T;
+}

package/src/caching.ts

@@ -34,6 +34,7 @@ export function cacheEmptyArray<T>(array: T[]): T[] {
 export function cache<Output, Key>(getValue: (key: Key) => Output): {
     (key: Key): Output;
     clear(key: Key): void;
+    forceSet(key: Key, value: Output): void;
 } {
     let startingCalculating = new Set<Key>();
     let values = new Map<Key, Output>();
@@ -54,6 +55,11 @@ export function cache<Output, Key>(getValue: (key: Key) => Output): {
     }
     cache.clear = (key: Key) => {
         values.delete(key);
+        startingCalculating.delete(key);
+    };
+    cache.forceSet = (key: Key, value: Output) => {
+        values.set(key, value);
+        startingCalculating.add(key);
     };
     return cache;
 }
@@ -270,7 +276,7 @@ export function cacheShallowConfigArgEqual<Fnc extends AnyFunction>(
         }
         let keys = Object.keys(configArg);
         keys.sort();
-        return keys.flatMap(key => [key, (configArg as any)[key]]);
+        return keys.flatMap(key => [key, configArg[key]]);
     }
     let output = Object.assign(
         ((configArg: object) => {

package/src/callManager.ts

@@ -2,6 +2,7 @@ import { CallerContext, CallType, ClientHookContext, FullCallType, HookContext,
 import { _setSocketContext } from "../SocketFunction";
 import { isNode } from "./misc";
 import debugbreak from "debugbreak";
+import { measureWrap } from "./profiling/measure";
 
 let classes: {
     [classGuid: string]: {
@@ -92,11 +93,12 @@ export function unregisterGlobalClientHook(hook: SocketFunctionClientHook) {
     }
 }
 
-export async function runClientHooks(
+export const runClientHooks = measureWrap(async function runClientHooks(
     callType: FullCallType,
     hooks: SocketExposedShape[""],
+    connectionId: { nodeId: string },
 ): Promise<ClientHookContext> {
-    let context: ClientHookContext = { call: callType };
+    let context: ClientHookContext = { call: callType, connectionId };
 
     let clientHooks = (
         globalClientHooks
@@ -113,10 +115,11 @@ export async function runClientHooks(
             break;
         }
     }
+
     return context;
-}
+});
 
-async function runServerHooks(
+export const runServerHooks = measureWrap(async function runServerHooks(
     callType: FullCallType,
     caller: CallerContext,
     hooks: SocketExposedShape[""],
@@ -129,4 +132,4 @@ async function runServerHooks(
         }
     }
     return hookContext;
-}
+});

package/src/certStore.ts

@@ -1,4 +1,5 @@
 import * as tls from "tls";
+import { sha256Hash } from "./misc";
 
 let trustedCerts = new Set<string>();
 let watchCallbacks = new Set<(certs: string[]) => void>();
@@ -14,6 +15,7 @@ export function trustCertificate(cert: string | Buffer) {
     }
 }
 export function getTrustedCertificates(): string[] {
+    //console.log(`trustedCerts = ${Array.from(trustedCerts).map(x => sha256Hash(x).slice(0, 10))}`);
     return tls.rootCertificates.concat(Array.from(trustedCerts));
 }
 

package/src/formatting/colors.ts

@@ -0,0 +1,79 @@
+export type HSL = { h: number, s: number, l: number };
+export function hslText(color: HSL): string {
+    return `hsl(${color.h}, ${color.s}%, ${color.l}%)`;
+}
+
+export function hslToRGB(color: HSL) {
+    let { h, s, l } = color;
+    h /= 360;
+    s /= 100;
+    l /= 100;
+    let r, g, b;
+    if (s === 0) {
+        r = g = b = l; // achromatic
+    } else {
+        const hue2rgb = (p: number, q: number, t: number) => {
+            if (t < 0) t += 1;
+            if (t > 1) t -= 1;
+            if (t < 1 / 6) return p + (q - p) * 6 * t;
+            if (t < 1 / 2) return q;
+            if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+            return p;
+        };
+        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        const p = 2 * l - q;
+        r = hue2rgb(p, q, h + 1 / 3);
+        g = hue2rgb(p, q, h);
+        b = hue2rgb(p, q, h - 1 / 3);
+        if (b < 0) {
+            b = 0;
+        }
+    }
+    return { r: Math.floor(r * 255), g: Math.floor(g * 255), b: Math.floor(b * 255) };
+}
+
+export function hslToHex(color: HSL) {
+    let { r, g, b } = hslToRGB(color);
+    const toHex = (x: number) => {
+        const hex = x.toString(16);
+        return hex.length === 1 ? "0" + hex : hex;
+    };
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+
+// Consider 
+export function hslLightenGamma(hsl: HSL, fraction: number) {
+    let l = ((hsl.l ** 2) * (1 + fraction)) ** 0.5;
+    if (l > 255) l = 255;
+    if (!l || l < 0) l = 0;
+    return { h: hsl.h, s: hsl.s, l };
+}
+export function hslLightenLinear(hsl: HSL, lightness: number) {
+    let l = hsl.l + lightness;
+    if (l > 255) l = 255;
+    if (!l || l < 0) l = 0;
+    return { h: hsl.h, s: hsl.s, l };
+}
+export function hslDarkenGamma(hsl: HSL, fraction: number) {
+    return hslLightenGamma(hsl, -fraction);
+}
+export function hslDarkenLinear(hsl: HSL, lightness: number) {
+    return hslLightenLinear(hsl, -lightness);
+}
+
+export function hslAddSaturate(hsl: HSL, saturation: number) {
+    // If something has ZERO saturation, the color is meaningless, so increasing the saturation
+    //  will likely not give the desired impact. Instead, darken the grey, which should give the desire effect.
+    if (hsl.s === 0) {
+        return hslDarkenGamma(hsl, 0.2);
+    }
+    return { h: hsl.h, s: hsl.s + saturation, l: hsl.l };
+}
+export function hslSetSaturate(hsl: HSL, saturation: number) {
+    // If something has ZERO saturation, the color is meaningless, so increasing the saturation
+    //  will likely not give the desired impact. Instead, set the lightness.
+    if (hsl.s === 0) {
+        return { h: hsl.h, s: hsl.s, l: 100 - saturation };
+    }
+    return { h: hsl.h, s: saturation, l: hsl.l };
+}

package/src/formatting/format.ts

@@ -0,0 +1,157 @@
+export function formatTime(milliseconds: number | undefined): string {
+    if (typeof milliseconds !== "number") return "";
+    if (milliseconds === 0) return "0ms";
+    if (milliseconds < 0) {
+        return "-" + formatTime(-milliseconds);
+    }
+    if (milliseconds < 1 / 1000) {
+        return formatMaxDecimals(milliseconds * 1000 * 1000, 3) + "ns";
+    } else if (milliseconds < 1) {
+        return formatMaxDecimals(milliseconds * 1000, 3) + "us";
+    } else if (milliseconds < 1000) {
+        return formatMaxDecimals(milliseconds, 3) + "ms";
+        // Use seconds until we have 10 minutes, as decimal minutes are confusing
+    } else if (milliseconds < 1000 * 60 * 10) {
+        return formatMaxDecimals(milliseconds / 1000, 3) + "s";
+    } else if (milliseconds < 1000 * 60 * 60) {
+        return formatMaxDecimals(milliseconds / 1000 / 60, 3) + "m";
+    } else if (milliseconds < 1000 * 60 * 60 * 24) {
+        return formatMaxDecimals(milliseconds / 1000 / 60 / 60, 3) + "h";
+        // } else if (milliseconds < 1000 * 60 * 60 * 24 * 10) {
+        //     let remaining = Math.round(milliseconds / 1000);
+        //     let seconds = remaining % 60;
+        //     remaining -= seconds;
+        //     remaining /= 60;
+        //     let minutes = remaining % 60;
+        //     remaining -= minutes;
+        //     remaining /= 60;
+        //     let hours = remaining;
+        //     remaining -= hours;
+        //     remaining /= 24;
+        //     let days = remaining;
+        //     let time = `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+        //     if (days > 0) {
+        //         if (days === 1) {
+        //             time = `1 day ${time}`;
+        //         } else {
+        //             time = `${days} days ${time}`;
+        //         }
+        //     }
+        //     return time;
+    } else {
+        let days = Math.round(milliseconds / 1000 / 60 / 60 / 24);
+        return `${days} days`;
+    }
+}
+
+export function getTargetDecimals(maxAbsoluteValue: number, targetDigits: number) {
+    let intDigits = Math.floor(Math.log10(maxAbsoluteValue) + 1);
+    if (intDigits < 0) intDigits = 1;
+    let decimalDigits = targetDigits - intDigits;
+    // Happens if the number is so close to having too many digits that Math.log10 rounds it over.
+    if (decimalDigits < 0) {
+        decimalDigits = 0;
+    }
+    return decimalDigits;
+}
+
+/** Adds decimal digits to reach digits. If the number is simply too large, it won't remove
+ *      digits, there will instead just be no decimal point.
+ */
+export function formatMaxDecimals(num: number, targetDigits: number, maxAbsoluteValue?: number, exactDecimals?: number): string {
+    if (typeof num !== "number") return "0";
+    // toFixed has a max of 100 digits
+    if (targetDigits > 100) targetDigits = 100;
+    if (!Number.isFinite(num)) return num.toFixed(targetDigits);
+
+    if (num < 0) return formatMaxDecimals(-num, targetDigits, maxAbsoluteValue, exactDecimals);
+
+    // TIMING:
+    //  ~50ns   toString
+    //  ~400ns  toLocaleString
+    //  ~500ns  toLocaleString("en-us")
+    //  ~20us   toLocaleString("en-us", { maximumFractionDigits: 2 })
+    // So, we are avoiding using toLocaleString, for now.
+
+    maxAbsoluteValue = maxAbsoluteValue ?? Math.abs(num);
+
+    let targetDecimals = exactDecimals ?? getTargetDecimals(maxAbsoluteValue, targetDigits);
+    let text = num.toFixed(targetDecimals);
+    let parts = text.split(".");
+    let integer = parts[0];
+    let decimals = parts[1] ?? "";
+
+    if (exactDecimals) {
+        while (decimals.length < exactDecimals) {
+            decimals += "0";
+        }
+    } else {
+        while (decimals[decimals.length - 1] === "0") {
+            decimals = decimals.slice(0, -1);
+        }
+    }
+
+    let output = "";
+
+    // NOTE: ONLY add comma groups if it is > 4 digits. As 4234K is easily read, and commas
+    //  only really matter for numbers such as 4234523K, which is hard to read.
+    if (integer.length > 4) {
+        for (let i = integer.length; i > 0; i -= 3) {
+            let start = i - 3;
+            if (start < 0) start = 0;
+            let str = integer.slice(start, i);
+            if (output) {
+                output = "," + output;
+            }
+            output = str + output;
+        }
+    } else {
+        output = integer;
+    }
+
+    if (decimals) {
+        output += "." + decimals;
+    }
+
+    return output;
+}
+
+/** Actually formats any number, including decimals, by using K, M and B suffixes to get smaller values
+ *      TODO: Support uK, uM and uB suffixes for very small numbers?
+ */
+export function formatNumber(count: number | undefined, maxAbsoluteValue?: number, noDecimal?: boolean, specialCurrency?: boolean): string {
+    if (typeof count !== "number") return "0";
+    if (count < 0) {
+        return "-" + formatNumber(-count, maxAbsoluteValue, noDecimal, specialCurrency);
+    }
+
+    maxAbsoluteValue = maxAbsoluteValue ?? Math.abs(count);
+
+    // NOTE: We don't switch units as soon as we possible can, because...
+    //  3.594 vs 3.584 is harder to quickly distinguish compared to 3594 and 3584,
+    //  the decimal simply makes it harder to read, and larger.
+    const extraFactor = 10;
+    let divisor = 1;
+    let suffix = "";
+    let currencyDecimalsNeeded = false;
+    if (maxAbsoluteValue < 1000 * extraFactor) {
+        if (specialCurrency) {
+            currencyDecimalsNeeded = true;
+        }
+    } else if (maxAbsoluteValue < 1000 * 1000 * extraFactor) {
+        suffix = "K";
+        divisor = 1000;
+    } else if (maxAbsoluteValue < 1000 * 1000 * 1000 * extraFactor) {
+        suffix = "M";
+        divisor = 1000 * 1000;
+    } else {
+        suffix = "B";
+        divisor = 1000 * 1000 * 1000;
+    }
+    count /= divisor;
+    maxAbsoluteValue /= divisor;
+
+    let maxDecimals = noDecimal ? 0 : 3;
+
+    return formatMaxDecimals(count, maxDecimals, maxAbsoluteValue, currencyDecimalsNeeded ? 2 : undefined) + suffix;
+}

package/src/formatting/logColors.ts

@@ -0,0 +1,18 @@
+import { hslToHex, hslToRGB } from "./colors";
+
+function ansiHSL(h: number, s: number, l: number, text: string): string {
+    let { r, g, b } = hslToRGB({ h, s, l });
+    return ansiRGB(r, g, b, text);
+}
+function ansiRGB(r: number, g: number, b: number, text: string): string {
+    return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
+}
+
+const lightness = 68;
+export const blue = ansiHSL.bind(null, 235, 100, lightness);
+export const red = ansiHSL.bind(null, 0, 100, lightness);
+export const green = (text: string) => `\x1b[32m${text}\x1b[39m`; // chalk.hsl(120, 100, lightness).bind(chalk);
+export const yellow = (text: string) => `\x1b[33m${text}\x1b[39m`;
+export const white = ansiHSL.bind(null, 0, 0, 80);
+
+export const magenta = (text: string) => `\x1b[35m${text}\x1b[39m`;

package/src/misc.ts

@@ -1,5 +1,5 @@
 import * as crypto from "crypto";
-import { MaybePromise } from "./types";
+import { canHaveChildren, MaybePromise } from "./types";
 
 export type Watchable<T> = (callback: (value: T) => void) => MaybePromise<void>;
 
@@ -10,9 +10,12 @@ export function convertErrorStackToError(error: string): Error {
     return errorObj;
 }
 
-export function sha256Hash(buffer: Buffer | string) {
+export function sha256Hash(buffer: Buffer | string): string {
     return crypto.createHash("sha256").update(buffer).digest("hex");
 }
+export function sha256HashBuffer(buffer: Buffer | string): Buffer {
+    return crypto.createHash("sha256").update(buffer).digest();
+}
 /** Async, but works both clientside and serverside. */
 export async function sha256HashPromise(buffer: Buffer) {
     if (isNode()) {
@@ -22,6 +25,14 @@ export async function sha256HashPromise(buffer: Buffer) {
         return Buffer.from(buf).toString("hex");
     }
 }
+export async function sha256BufferPromise(buffer: Buffer): Promise<Buffer> {
+    if (isNode()) {
+        return crypto.createHash("sha256").update(buffer).digest();
+    } else {
+        let buf = await window.crypto.subtle.digest("SHA-256", buffer);
+        return Buffer.from(buf);
+    }
+}
 
 
 export function arrayEqual(a: unknown[], b: unknown[]) {
@@ -68,6 +79,67 @@ export function formatNumberSuffixed(count: number): string {
     return Math.round(count).toString() + suffix;
 }
 
+export function list(count: number) {
+    let arr: number[] = [];
+    for (let i = 0; i < count; i++) {
+        arr.push(i);
+    }
+    return arr;
+}
+
+export function recursiveFreeze<T>(obj: T): T {
+    if (!canHaveChildren(obj)) return obj;
+    let visited = new Set<unknown>();
+    function iterate(obj: unknown) {
+        if (!canHaveChildren(obj)) return;
+        if (visited.has(obj)) return;
+        visited.add(obj);
+        Object.freeze(obj);
+        let keys = getKeys(obj);
+        for (let key of keys) {
+            iterate(obj[key]);
+        }
+    }
+    iterate(obj);
+    return obj;
+}
+export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
+export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
+export function isBufferType(obj: unknown): obj is BufferType {
+    if (typeof obj !== "object") return false;
+    if (!obj) return false;
+    if (ArrayBuffer.isView(obj)) return true;
+    if (obj instanceof ArrayBuffer) return true;
+    if (global.SharedArrayBuffer && obj instanceof global.SharedArrayBuffer) return true;
+    return false;
+}
+export function getKeys(obj: unknown) {
+    if (typeof obj !== "object" && typeof obj !== "function" || obj === null) {
+        return [];
+    }
+    if (obj instanceof MessagePort) {
+        return [];
+    }
+    let keyArray: PropertyKey[];
+    if (isBufferType(obj)) {
+        keyArray = [];
+    } else if (Array.isArray(obj)) {
+        // NOTE: We convert the indexes to strings, because that is what javascript does,
+        //  and differing from it causes regressions that we simply cannot rectify (it breaks hashing
+        //  consistency).
+        keyArray = Array(obj.length).fill(0).map((x, i) => String(i));
+    } else {
+        keyArray = Object.keys(obj);
+    }
+    for (let symbol of Object.getOwnPropertySymbols(obj)) {
+        let key = Symbol.keyFor(symbol);
+        if (key) {
+            keyArray.push(symbol);
+        }
+    }
+    return keyArray;
+}
+
 if (isNode()) {
     // TODO: Find a better place for this...
     process.on("unhandledRejection", async (reason: any, promise) => {

package/src/nodeCache.ts

@@ -21,19 +21,22 @@ export function getNodeId(domain: string, port: number): string {
 export function getClientNodeId(address: string): string {
     return `client:${address}:${Date.now()}:${Math.random()}`;
 }
+export function isClientNodeId(nodeId: string): boolean {
+    return nodeId.startsWith("client:");
+}
 /** Will always be available, even if getNodeIdLocation is not (as we don't always have the port,
  *      but we should always have an address).
  *  - Rarely used, as for logging you can just log the nodeId. ALSO, it isn't sufficient to reconnect, as the port is also needed!
  *  */
 export function getNodeIdIP(nodeId: string): string {
-    if (nodeId.startsWith("client:")) {
+    if (isClientNodeId(nodeId)) {
         return nodeId.split(":")[1];
     }
     return getNodeIdLocation(nodeId)!.address;
 }
 
 export function getNodeIdLocation(nodeId: string): { address: string, port: number; } | undefined {
-    if (nodeId.startsWith("client:")) {
+    if (isClientNodeId(nodeId)) {
         return undefined;
     }
     let [address, port] = nodeId.split(":");
@@ -59,10 +62,10 @@ export function registerNodeClient(callFactory: CallFactory) {
     startCleanupLoop();
 }
 
-export function getCreateCallFactory(nodeId: string, mountedNodeId: string): MaybePromise<CallFactory> {
+export function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory> {
     let callFactory = nodeCache.get(nodeId);
     if (callFactory === undefined) {
-        callFactory = createCallFactory(undefined, nodeId, mountedNodeId);
+        callFactory = createCallFactory(undefined, nodeId);
         nodeCache.set(nodeId, callFactory);
     }
     return callFactory;