socket-function 0.78.0 → 0.80.0

package/package.json

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

package/require/RequireController.ts

@@ -243,9 +243,10 @@ class RequireControllerBase {
                 asyncRequests: module.asyncRequires || {},
                 flags: {},
             };
+            let flags = modules[module.filename].flags!;
             for (let [flag, value] of Object.entries(module)) {
                 if (value === true) {
-                    modules[module.filename].flags![flag] = value;
+                    flags[flag] = value;
                 }
             }
             let moduleObj = modules[module.filename];

package/require/require.ts

@@ -82,6 +82,10 @@ export function requireMain() {
     let startTime = Date.now();
     globalThis.BOOT_TIME = startTime;
 
+    // Set to the first rootDomain, unless the first import does not have a domain
+    let mainRootOrigin = location.origin + location.pathname;
+    let isFirstImport = true;
+
     (Symbol as any).dispose = Symbol.dispose || Symbol("dispose");
     (Symbol as any).asyncDispose = Symbol.asyncDispose || Symbol("asyncDispose");
 
@@ -165,7 +169,7 @@ export function requireMain() {
             source?: string;
         }
     }} */
-    let serializedModules = Object.create(null);
+    let serializedModules: { [id: string]: SerializedModule | undefined } = Object.create(null);
 
     type ModuleType = {
         id: string;
@@ -203,6 +207,16 @@ export function requireMain() {
 
     let requireBatch: { [request: string]: (() => void)[] } | undefined;
     function rootRequire(request: string, batch?: boolean): unknown {
+        if (isFirstImport) {
+            isFirstImport = false;
+            if (request.startsWith("https://")) {
+                mainRootOrigin = getRootDomain(request);
+            }
+        }
+        if (!request.startsWith("https://")) {
+            request = mainRootOrigin + request;
+        }
+
         if (!batch) {
             if (request in rootResolveCache) {
                 let resolvedRequest = rootResolveCache[request];
@@ -247,6 +261,21 @@ export function requireMain() {
             return rootRequireMultiple([request]).then((x) => x[0].exports);
         }
     }
+
+    function getRootDomain(request: string) {
+        let url = new URL(request);
+        let origin = url.origin;
+        // Fix stupid :443 erasure (other ports aren't erased, except 80, but we'll never use HTTP,
+        //  so that's fine).
+        {
+            let remaining = request.slice(origin.length);
+            if (remaining.startsWith(":443/")) {
+                origin += ":443";
+            }
+        }
+        return origin + "/";
+    }
+
     async function rootRequireMultiple(requests: string[]) {
         console.log(`%cimport(${requests.join(", ")}) at ${Date.now() - startTime}ms`, "color: orange");
 
@@ -280,21 +309,12 @@ export function requireMain() {
                 if (!request.startsWith("https://")) {
                     throw new Error(`Mixed domains with non-domain requests is not supported presently. Requests: ${requests.join(" | ")}`);
                 }
-                let url = new URL(request);
-                let origin = url.origin;
-                // Fix stupid :443 erasure (other ports aren't erased, except 80, but we'll never use HTTP,
-                //  so that's fine).
-                {
-                    let remaining = request.slice(origin.length);
-                    if (remaining.startsWith(":443/")) {
-                        origin += ":443";
-                    }
-                }
+                let origin = getRootDomain(request);
                 if (domainOrigin && domainOrigin !== origin) {
                     // TODO: If this happens, we can probably just split the call up into multiple calls?
                     throw new Error(`Mixed domains in require call is not supported presently. Requests: ${requests.join(" | ")}`);
                 }
-                domainOrigin = origin + "/";
+                domainOrigin = origin;
                 // By stripping by length, we can turn https://example.com/./test => "./test"
                 //  (where as if we used pathname, it would turn into "/test"
                 return request.slice(domainOrigin.length);
@@ -468,14 +488,14 @@ export function requireMain() {
                 return builtInModuleExports[request as keyof typeof builtInModuleExports];
             }
 
-            let resolvedPath;
+            let resolvedPath: string | undefined;
             if (request in moduleCache) {
                 resolvedPath = request;
             } else {
                 if (!(request in serializedModule.requests)) {
                     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.`,
+                            `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. Expected imports: ${Object.keys(serializedModule.requests).join(" | ")}`,
                             "color: red",
                             "color: unset",
                             "color: red",
@@ -487,6 +507,11 @@ export function requireMain() {
                     //  (This path isn't hit often, as we usually preload, but... sometimes we won't).
                     if (request.startsWith(".")) {
                         request = moduleFolder + request;
+                    } else {
+                        // Still use the same domain
+                        if (!request.startsWith("https://")) {
+                            request = getRootDomain(request) + request;
+                        }
                     }
                     return rootRequire(request);
                 }
@@ -501,7 +526,7 @@ export function requireMain() {
             if (resolvedPath !== "NOTALLOWEDCLIENTSIDE" && !serializedModules[resolvedPath]) {
                 if (!asyncIsFine) {
                     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.`,
+                        `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. Expected imports: ${Object.keys(serializedModule.requests).join(" | ")}`,
                         "color: red",
                         "color: unset",
                         "color: red",
@@ -512,7 +537,7 @@ export function requireMain() {
             }
 
             let exportsOverride: unknown | undefined;
-            if (resolvedPath === "NOTALLOWEDCLIENTSIDE" || !serializedModules[resolvedPath].allowclient) {
+            if (resolvedPath === "NOTALLOWEDCLIENTSIDE" || !serializedModules[resolvedPath]?.allowclient) {
                 let childId = resolvedPath === "NOTALLOWEDCLIENTSIDE" ? request : resolvedPath;
                 if (serializedModules[resolvedPath]?.serveronly) {
                     exportsOverride = new Proxy(
@@ -540,8 +565,13 @@ export function requireMain() {
                                 if (property === unloadedModule) return true;
                                 if (property === "default") return exportsOverride;
 
+                                let type = "non-whitelisted";
+                                if (!serializedModules[resolvedPath!]) {
+                                    type = "missing module";
+                                }
+
                                 console.warn(
-                                    `Accessed non-whitelisted module %c${childId}%c, specifically property %c${String(
+                                    `Accessed ${type} module %c${childId}%c, specifically property %c${String(
                                         property
                                     )}%c.\n\tAdd %cmodule.allowclient = true%c to the file to allow access.\n\t(IF it is a 3rd party library, use the global "setFlag" helper (in the file you imported the module) to set properties on other modules (it can even recursively set properties)).\n\n\tFrom ${module.id
                                     }`,
@@ -623,6 +653,16 @@ export function requireMain() {
         }
 
         let serializedModule = serializedModules[resolvedId];
+        if (!serializedModule) {
+            // I can't figure out why this happens as it seems to happen very rarely and only when I'm debugging other code.
+            //  - I have had it happen immediately after starting the app. Although in theory a hot reload could have
+            //      triggered due to VS code writing to a file. 
+            //  - I've had times when it happens once after startup and then it goes away and other times where it
+            //      happens every single time and never goes away until I restart aipaint.
+            //  - Maybe it happens if we switch servers and so the root paths are different in some way?
+            debugger;
+            console.warn(`Failed to find module ${resolvedId}. The server should have given an error about this.`, serializedModules);
+        }
 
         let module = Object.create(null);
         moduleCache[resolvedId] = module;
@@ -631,14 +671,14 @@ export function requireMain() {
         module.exports = {};
         module.exports.default = module.exports;
         module.children = [];
-        for (let key in serializedModule.flags || {}) {
+        for (let key in serializedModule?.flags || {}) {
             if (key === "loaded") continue;
             module[key] = true;
         }
 
         module.load = load;
 
-        let originalSource = serializedModule.source;
+        let originalSource = serializedModule?.source || "";
         let moduleFnc = wrapSafe(module.id, originalSource);
 
         globalThis.onProgressHandler?.({
@@ -653,7 +693,8 @@ export function requireMain() {
         }
 
         function load() {
-            let serializedModule = serializedModules[resolvedId];
+            const serializedModule = serializedModules[resolvedId];
+            if (!serializedModule) return;
             if (!module.loaded) {
                 if (alreadyHave) {
                     delete alreadyHave.seqNums[serializedModule.seqNum];