socket-function 0.10.1 → 0.10.3

package/hot/HotReloadController.ts

@@ -41,6 +41,14 @@ declare global {
     }
 }
 
+let isHotReloadingValue = false;
+export function isHotReloading() {
+    return isHotReloadingValue;
+}
+export function setExternalHotReloading(value: boolean) {
+    isHotReloadingValue = value;
+}
+
 const hotReloadModule = cache((module: NodeJS.Module) => {
     if (!module.updateContents) return;
     fs.watchFile(module.filename, { persistent: false, interval: 1000 }, (curr, prev) => {
@@ -55,12 +63,15 @@ const hotReloadModule = cache((module: NodeJS.Module) => {
                 || module.moduleContents?.includes("\r\nmodule.hotreload = true;" + "\r\n")
             ) {
                 console.log(`Reloading ${module.id}`);
+                isHotReloadingValue = true;
                 try {
                     module.loaded = false;
                     module.load(module.id);
                 } catch (e) {
                     console.error(red(`Error hot reloading ${module.id}`));
                     console.error(e);
+                } finally {
+                    isHotReloadingValue = false;
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.10.1",
+	"version": "0.10.3",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -11,7 +11,7 @@
 		"mobx": "^6.6.2",
 		"node-forge": "https://github.com/sliftist/forge#name",
 		"preact": "^10.10.6",
-		"typenode": "5.3.3",
+		"typenode": "^5.3.8",
 		"ws": "^8.8.0"
 	},
 	"optionalDependencies": {

package/src/batching.ts

@@ -61,7 +61,7 @@ export function batchFunction<Arg, Result = void>(
     fnc = measureWrap(fnc, config.name);
 
     let prevPromise: Promise<Result> | undefined;
-    let batched: {
+    let batching: {
         args: Arg[];
         promise: Promise<Result>;
     } | undefined;
@@ -76,7 +76,8 @@ export function batchFunction<Arg, Result = void>(
     }
     let countSinceBreak = 0;
     let lastCall = 0;
-    return async arg => {
+
+    return arg => {
         let now = Date.now();
         if (delayRamp) {
             let savedCount = (now - lastCall) / delayTime;
@@ -94,30 +95,25 @@ export function batchFunction<Arg, Result = void>(
         }
         lastCall = now;
 
-        if (!batched) {
-            await prevPromise;
-        }
-        if (batched) {
-            batched.args.push(arg);
-            return await batched.promise;
+        if (batching) {
+            batching.args.push(arg);
+            return batching.promise;
         }
 
+        let curPrevPromise = prevPromise;
         let args: Arg[] = [arg];
         let promise = Promise.resolve().then(async () => {
+            await curPrevPromise;
             await delay(curDelay);
-            // After we call the function, we can no longer accept args
-            batched = undefined;
+            // Reset batching, as we once we start the function we can't accept args. `prevPromise` will block
+            //  the next batch from starting before we finish.
+            batching = 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;
+        batching = { args, promise, };
+        prevPromise = batching.promise;
 
-        return await promise;
+        return promise;
     };
 }
 

package/src/formatting/format.ts

@@ -162,5 +162,47 @@ export function formatNumber(count: number | undefined, maxAbsoluteValue?: numbe
 
     let maxDecimals = noDecimal ? 0 : 3;
 
+    return formatMaxDecimals(count, maxDecimals, maxAbsoluteValue, currencyDecimalsNeeded ? 2 : undefined) + suffix;
+}
+
+export function formatBinaryNumber(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.
+    // NOTE: This number should prevent us from ever using 5 digits, so that we never need commas
+    //  For example, if the factor is 10 then, 9999.5 is kept with a divisor of 1, and then rounds up to
+    //  "10,000". So we want any value which rounds up at 5 digits to be put in the next group (and having
+    //  extra values put in the next group is fine, as we won't show the decimal value anyways, so it only
+    //  means 9999 wraps around to 10K a bit faster).
+    const extraFactor = 9.99949999;
+    let divisor = 1;
+    let suffix = "";
+    let currencyDecimalsNeeded = false;
+    if (maxAbsoluteValue < 1024 * extraFactor) {
+        if (specialCurrency) {
+            currencyDecimalsNeeded = true;
+        }
+    } else if (maxAbsoluteValue < 1024 * 1024 * extraFactor) {
+        suffix = "K";
+        divisor = 1024;
+    } else if (maxAbsoluteValue < 1024 * 1024 * 1024 * extraFactor) {
+        suffix = "M";
+        divisor = 1024 * 1024;
+    } else {
+        suffix = "G";
+        divisor = 1024 * 1024 * 1024;
+    }
+    count /= divisor;
+    maxAbsoluteValue /= divisor;
+
+    let maxDecimals = noDecimal ? 0 : 3;
+
     return formatMaxDecimals(count, maxDecimals, maxAbsoluteValue, currencyDecimalsNeeded ? 2 : undefined) + suffix;
 }

package/src/misc.ts

@@ -42,7 +42,7 @@ export async function sha256BufferPromise(buffer: Buffer): Promise<Buffer> {
 }
 
 
-export function arrayEqual(a: unknown[], b: unknown[]) {
+export function arrayEqual(a: { [key: number]: unknown; length: number }, b: { [key: number]: unknown; length: number },) {
     if (a.length !== b.length) return false;
     for (let i = 0; i < a.length; i++) {
         if (a[i] !== b[i]) return false;

package/src/profiling/measure.ts

@@ -115,6 +115,8 @@ export interface LogMeasureTableConfig {
     thresholdInTable?: number;
     // Details to 50
     minTimeToLog?: number;
+    // Defaults to 2
+    mergeDepth?: number;
 }
 
 export function logMeasureTable(
@@ -136,6 +138,25 @@ export function logMeasureTable(
     let totalTime = entries.map(x => getTime(x).sum).reduce((a, b) => a + b, 0);
     if (totalTime < minTimeToLog) return;
 
+    let mergeDepth = config?.mergeDepth ?? 2;
+    {
+        let merged = new Map<string, ProfileEntry>();
+        for (let entry of entries) {
+            let parts = entry.name.split("|");
+            let key = parts.slice(0, mergeDepth).join("|");
+            let existing = merged.get(key);
+            if (!existing) {
+                existing = { name: key, ownTime: createStatsValue(), totalTime: createStatsValue(), stillOpenCount: 0 };
+                merged.set(key, existing);
+            }
+            addToStats(existing.ownTime, entry.ownTime);
+            addToStats(existing.totalTime, entry.totalTime);
+            existing.stillOpenCount += entry.stillOpenCount;
+        }
+        entries = Array.from(merged.values());
+        entries.sort((a, b) => getTime(b).sum - getTime(a).sum);
+    }
+
     console.log();
     let title = yellow(`Profiled ${formatTime(totalTime)} (logged at ${new Date().toISOString()})`);
     if (name) {