socket-function 0.10.2 → 0.10.4

package/SocketFunction.ts

@@ -65,6 +65,7 @@ export class SocketFunction {
         Shape extends SocketExposedShape<{
             [key in keyof ClassInstance]: (...args: any[]) => Promise<unknown>;
         }>,
+        Statics
     >(
         classGuid: string,
         instance: ClassInstance,
@@ -75,8 +76,9 @@ export class SocketFunction {
         config?: {
             /** @noAutoExpose If true SocketFunction.expose(Controller) must be called explicitly. */
             noAutoExpose?: boolean;
+            statics?: Statics;
         }
-    ): SocketRegistered<ExtractShape<ClassInstance, Shape>> {
+    ): SocketRegistered<ExtractShape<ClassInstance, Shape>> & Statics {
         let getDefaultHooks = defaultHooksFnc && lazy(defaultHooksFnc);
         const getShape = lazy(() => {
             let shape = shapeFnc() as SocketExposedShape;
@@ -146,7 +148,7 @@ export class SocketFunction {
         if (!config?.noAutoExpose) {
             this.expose(result);
         }
-        return result;
+        return Object.assign(result, config?.statics);
     }
 
     public static onNextDisconnect(nodeId: string, callback: () => void) {

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.2",
+	"version": "0.10.4",
 	"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/require/RequireController.ts

@@ -64,6 +64,8 @@ const requireSeqNumProcessId = "requireSeqNumProcessId_" + Date.now() + "_" + Ma
 const htmlFile = isNodeTrue() && fs.readFileSync(__dirname + "/require.html").toString();
 const jsFile = isNodeTrue() && fs.readFileSync(__dirname + "/require.js").toString();
 const bufferShim = isNodeTrue() && fs.readFileSync(__dirname + "/buffer.js").toString();
+const BEFORE_ENTRY_TEMPLATE = "<!-- BEFORE_ENTRY_TEMPLATE -->";
+const ENTRY_TEMPLATE = "<!-- ENTRY_TEMPLATE -->";
 
 const resolvedHTMLFile = isNodeTrue() && (
     htmlFile
@@ -71,13 +73,30 @@ const resolvedHTMLFile = isNodeTrue() && (
         .replace(`<script src="./require.js"></script>`, `<script>${jsFile}</script>`)
 );
 
+let beforeEntryText: string[] = [];
+function injectHTMLBeforeStartup(text: string) {
+    beforeEntryText.push(text);
+}
+
+type GetModulesResult = ReturnType<RequireControllerBase["getModules"]> extends Promise<infer T> ? T : never;
+type GetModulesArgs = Parameters<RequireControllerBase["getModules"]>;
+let mapGetModules: {
+    remap(result: GetModulesResult, args: GetModulesArgs): Promise<GetModulesResult>
+}[] = [];
+function addMapGetModules(remap: typeof mapGetModules[number]["remap"]) {
+    mapGetModules.push({ remap });
+}
+
 class RequireControllerBase {
     public rootResolvePath = "";
 
     public async requireHTML(bootRequirePath?: string) {
         let result = resolvedHTMLFile;
+        if (beforeEntryText.length > 0) {
+            result = result.replace(BEFORE_ENTRY_TEMPLATE, beforeEntryText.join("\n"));
+        }
         if (bootRequirePath) {
-            result = result.replace(`<!-- ENTRY_TEMPLATE -->`, `<script>require(${JSON.stringify(bootRequirePath)});</script>`);
+            result = result.replace(ENTRY_TEMPLATE, `<script>require(${JSON.stringify(bootRequirePath)});</script>`);
         }
         return setHTTPResultHeaders(Buffer.from(result), { "Content-Type": "text/html" });
     }
@@ -101,6 +120,7 @@ class RequireControllerBase {
                 e?: number;
             }[];
         },
+        config?: {}
     ): Promise<{
         requestsResolvedPaths: string[];
         modules: {
@@ -232,10 +252,21 @@ class RequireControllerBase {
             addModule(clientModule, true);
         }
 
-        return { requestsResolvedPaths, modules, requireSeqNumProcessId };
+        let result: GetModulesResult = { requestsResolvedPaths, modules, requireSeqNumProcessId };
+        for (let remap of mapGetModules) {
+            result = await remap.remap(result, [pathRequests, alreadyHave, config]);
+        }
+        return result;
     }
 }
 
+type ClientRemapCallback = (args: GetModulesArgs) => Promise<GetModulesArgs>;
+declare global {
+    /** Must be set clientside BEFORE requests are made (so you likely want to use RequireController.addMapGetModules
+     *      to inject code that will use this) */
+    var remapImportRequestsClientside: undefined | ClientRemapCallback[];
+}
+
 let baseController = new RequireControllerBase();
 export function setRequireBootRequire(path: string) {
     baseController.rootResolvePath = path;
@@ -252,6 +283,10 @@ export const RequireController = SocketFunction.register(
     }),
     undefined,
     {
-        noAutoExpose: true
+        noAutoExpose: true,
+        statics: {
+            injectHTMLBeforeStartup,
+            addMapGetModules,
+        }
     }
 );

package/require/require.html

@@ -9,6 +9,7 @@
         <script src="./buffer.js"></script>
         <script src="./require.js"></script>
 
+        <!-- BEFORE_ENTRY_TEMPLATE -->
         <!-- ENTRY_TEMPLATE -->
     </body>
 </html>

package/require/require.js

@@ -166,6 +166,12 @@
             args.push(true);
         }
         let requestUrl = location.origin + location.pathname + `?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=getModules`;
+        let remapImportRequestsClientside = globalThis.remapImportRequestsClientside;
+        if (remapImportRequestsClientside) {
+            for (let fnc of remapImportRequestsClientside) {
+                args = await fnc(args);
+            }
+        }
         let rawText = await requestText(requestUrl, { args });
         let resultObj;
         try {

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) {