socket-function 0.12.5 → 0.12.7

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.12.5",
+	"version": "0.12.7",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -13,7 +13,7 @@
 		"node-forge": "https://github.com/sliftist/forge#name",
 		"pako": "^2.1.0",
 		"preact": "^10.10.6",
-		"typenode": "^5.3.11",
+		"typenode": "^5.3.12",
 		"ws": "^8.8.0"
 	},
 	"optionalDependencies": {

package/require/RequireController.ts

@@ -31,11 +31,16 @@ declare global {
             //  And... maybe it is useful in other cases?
             /** Used internally by RequireController */
             requireControllerSeqNum?: number;
+
+            // Times are both unique (two modules evaluated at the same Date.now() will have different values).
+            evalStartTime?: number;
+            evalEndTime?: number;
         }
     }
     interface Window {
         clientsideBootTime: number;
     }
+    var suppressUnexpectedModuleWarning: boolean;
 }
 
 export interface SerializedModule {
@@ -108,6 +113,9 @@ class RequireControllerBase {
         }
         if (requireCalls) {
             async function requireAll(calls: string[]) {
+                // NOTE: awaiting isn't just for better and consistent load order, it also greatly improves load efficiency,
+                //  as parallel calls can't know what files will be loaded, so there is a lot of duplicate loading. Loading
+                //  1 at a time allows require to efficiently require only files that previous imports haven't loaded.
                 for (let call of calls) {
                     try {
                         await require(call);

package/require/require.js

@@ -49,6 +49,17 @@
     };
     global.builtInModuleExports = builtInModuleExports;
 
+    let lastTime = 0;
+    function nextTime() {
+        let time = Date.now();
+        if (time <= lastTime) {
+            // NOTE: We SHOULD really add epsilon, but... this is a lot easier, and is close enough,
+            //  as times will never have too large of a magnitude.
+            time = lastTime + 0.01;
+        }
+        lastTime = time;
+        return time;
+    }
 
     /** @type {{
         [resolvePath: string]: {
@@ -233,6 +244,7 @@
             // TODO: Maybe do a request, making this async, if it isn't found?
             return serializedModule.requests[request];
         };
+        let moduleFolder = module.filename.replace(/\\/g, "/").split("/").slice(0, -1).join("/") + "/";
         return require;
         function require(request, asyncIsFine) {
             if (asyncIsFineOuter) {
@@ -250,12 +262,18 @@
                 resolvedPath = request;
             } else {
                 if (!(request in serializedModule.requests)) {
-                    if (!asyncIsFine) {
+                    if (!asyncIsFine && !globalThis.suppressUnexpectedModuleWarning) {
                         console.warn(`Accessed unexpected module %c${request}%c in %c${module.id}%c\n\tTreating it as an async require.\n\tAll modules require synchronously clientside must be required serverside at a module level.`,
                             "color: red", "color: unset",
                             "color: red", "color: unset",
                         );
                     }
+                    // NOTE: We should still namespace it to the current folder (if it is a relative path),
+                    //  otherwise relative async imports won't work!
+                    //  (This path isn't hit often, as we usually preload, but... sometimes we won't).
+                    if (request.startsWith(".")) {
+                        request = moduleFolder + request;
+                    }
                     return rootRequire(request);
                 }
 
@@ -421,6 +439,8 @@
             currentModuleEvaluationStack.push(module.filename);
             try {
                 module.isPreloading = true;
+                module.evalStartTime = nextTime();
+                module.evalEndTime = undefined;
                 moduleFnc.call(
                     {
                         // NOTE: Adding __importStar to the module causes typescript to use our implementation,
@@ -440,6 +460,7 @@
                     dirname,
                     importDynamic
                 );
+                module.evalEndTime = nextTime();
                 time = Date.now() - time;
                 // NOTE: This log statment is disabled as I believe it causes lag (when devtools is open).
                 //  As in, adding about 500ms to our load time, which is annoying when debugging.