socket-function 1.1.41 → 1.1.43

package/hot/HotReloadController.ts

@@ -4,6 +4,7 @@ module.allowclient = true;
 
 import { SocketFunction } from "../SocketFunction";
 import { cache, lazy } from "../src/caching";
+import { createSingleton } from "../src/createSingleton";
 import * as fs from "fs";
 import crypto from "crypto";
 import debugbreak from "debugbreak";
@@ -56,18 +57,23 @@ declare global {
     var isHotReloading: (() => boolean) | undefined;
 }
 
-let isHotReloadingValue = false;
+// Shared across copies of this package, so the "currently hot reloading" flag is consistent no
+//  matter which copy set it (ex, setExternalHotReloading) or reads it (callManager.registerClass
+//  reads it via the globalThis.isHotReloading bridge, which each copy overwrites). See createSingleton.
+const isHotReloadingState = createSingleton("HotReloadController.isHotReloading", 1, () => ({ value: false }));
 export function isHotReloading() {
-    return isHotReloadingValue;
+    return isHotReloadingState.get().value;
 }
 globalThis.isHotReloading = isHotReloading;
 export function hotReloadingGuard(): true {
     return !isHotReloading() as any;
 }
 export function setExternalHotReloading(value: boolean) {
-    isHotReloadingValue = value;
+    isHotReloadingState.get().value = value;
 }
-let hotReloadCallbacks: ((modules: NodeJS.Module[]) => void)[] = [];
+// Shared across copies, so callbacks registered through one copy's onHotReload still fire when the
+//  first-registered copy's controller performs a reload. See createSingleton.
+const hotReloadCallbacks = createSingleton("HotReloadController.hotReloadCallbacks", 1, () => [] as ((modules: NodeJS.Module[]) => void)[]).get();
 export function onHotReload(callback: (modules: NodeJS.Module[]) => void) {
     hotReloadCallbacks.push(callback);
 }
@@ -124,7 +130,7 @@ const hotReloadModule = cache((module: NodeJS.Module) => {
                 || module.moduleContents?.includes("\r\nmodule.hotreload = true;" + "\r\n")
             ) {
                 console.log(`Serverside reloading ${module.id}`);
-                isHotReloadingValue = true;
+                isHotReloadingState.get().value = true;
                 try {
                     module.loaded = false;
                     module.load(module.id);
@@ -133,7 +139,7 @@ const hotReloadModule = cache((module: NodeJS.Module) => {
                     console.error(e);
                 } finally {
                     setTimeout(() => {
-                        isHotReloadingValue = false;
+                        isHotReloadingState.get().value = false;
                     }, 1000);
                 }
             }
@@ -215,12 +221,12 @@ class HotReloadControllerBase {
             for (let module of modules) {
                 module.loaded = false;
             }
-            isHotReloadingValue = true;
+            isHotReloadingState.get().value = true;
             try {
                 await Promise.all(modules.map(module => module.load(module.filename)));
             } finally {
                 setTimeout(() => {
-                    isHotReloadingValue = false;
+                    isHotReloadingState.get().value = false;
                 }, 1000);
             }
 

package/index.d.ts

@@ -360,8 +360,14 @@ declare module "socket-function/require/RequireController" {
     declare function addStaticRoot(root: string): void;
     type GetModulesResult = ReturnType<RequireControllerBase["getModules"]> extends Promise<infer T> ? T : never;
     export type GetModulesArgs = Parameters<RequireControllerBase["getModules"]>;
-    declare let mapGetModules: {
-        remap(result: GetModulesResult, args: GetModulesArgs): Promise<GetModulesResult>;
+    declare const mapGetModules: {
+        remap(result: GetModulesResult, args: [pathRequests: string[], alreadyHave?: {
+            requireSeqNumProcessId: string;
+            seqNumRanges: {
+                s: number;
+                e?: number;
+            }[];
+        } | undefined, config?: {} | undefined]): Promise<GetModulesResult>;
     }[];
     declare function addMapGetModules(remap: typeof mapGetModules[number]["remap"]): void;
     declare class RequireControllerBase {

package/package.json

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

package/require/RequireController.d.ts

@@ -45,8 +45,14 @@ declare function injectHTMLBeforeStartup(text: string | (() => Promise<string>))
 declare function addStaticRoot(root: string): void;
 type GetModulesResult = ReturnType<RequireControllerBase["getModules"]> extends Promise<infer T> ? T : never;
 export type GetModulesArgs = Parameters<RequireControllerBase["getModules"]>;
-declare let mapGetModules: {
-    remap(result: GetModulesResult, args: GetModulesArgs): Promise<GetModulesResult>;
+declare const mapGetModules: {
+    remap(result: GetModulesResult, args: [pathRequests: string[], alreadyHave?: {
+        requireSeqNumProcessId: string;
+        seqNumRanges: {
+            s: number;
+            e?: number;
+        }[];
+    } | undefined, config?: {} | undefined]): Promise<GetModulesResult>;
 }[];
 declare function addMapGetModules(remap: typeof mapGetModules[number]["remap"]): void;
 declare class RequireControllerBase {

package/require/RequireController.ts

@@ -6,6 +6,7 @@ import { getCurrentHTTPRequest, setHTTPResultHeaders } from "../src/callHTTPHand
 import { formatNumberSuffixed, isNode, isNodeTrue, sha256Hash, sha256HashPromise } from "../src/misc";
 import zlib from "zlib";
 import { cacheLimited, lazy } from "../src/caching";
+import { createSingleton } from "../src/createSingleton";
 import { formatNumber } from "../src/formatting/format";
 import { requireMain } from "./require";
 import path from "path";
@@ -88,11 +89,16 @@ const resolvedHTMLFile = lazy(() => {
         );
 });
 
-let beforeEntryText: (string | (() => Promise<string>))[] = [];
+// All of these are mutated by the static helpers below (injectHTMLBeforeStartup, addStaticRoot,
+//  addMapGetModules), which callers invoke on RequireController. But only the first-registered
+//  copy's controller actually serves requireHTML/getModules, and it reads these vars. So they must
+//  be shared across copies, or a caller using a different copy would add (ex) before-entry HTML
+//  that the serving controller never reads. See createSingleton.
+const beforeEntryText = createSingleton("RequireController.beforeEntryText", 1, () => [] as (string | (() => Promise<string>))[]).get();
 function injectHTMLBeforeStartup(text: string | (() => Promise<string>)) {
     beforeEntryText.push(text);
 }
-let staticRoots: string[] = [];
+const staticRoots = createSingleton("RequireController.staticRoots", 1, () => [] as string[]).get();
 function addStaticRoot(root: string) {
     if (!root.endsWith("/")) {
         root += "/";
@@ -102,9 +108,9 @@ function addStaticRoot(root: string) {
 
 type GetModulesResult = ReturnType<RequireControllerBase["getModules"]> extends Promise<infer T> ? T : never;
 export type GetModulesArgs = Parameters<RequireControllerBase["getModules"]>;
-let mapGetModules: {
+const mapGetModules = createSingleton("RequireController.mapGetModules", 1, () => [] as {
     remap(result: GetModulesResult, args: GetModulesArgs): Promise<GetModulesResult>
-}[] = [];
+}[]).get();
 function addMapGetModules(remap: typeof mapGetModules[number]["remap"]) {
     mapGetModules.push({ remap });
 }
@@ -421,7 +427,7 @@ async function compressCached(bufferKey: string, buffer: () => Buffer): Promise<
 export function getIsAllowClient(module: NodeJS.Module) {
     if (module.serveronly) return false;
     // IMPORTANT! We do not allow everything in node modules by default, as most things in node modules, you don't want to import client-side, and it will break if you import it client-side. Many of these are imported, but will never end up being called client-side, so it's fine to exclude them.
-    if (allowAllNodeModulesFlag && module.filename.includes("node_modules")) {
+    if (allowAllNodeModulesFlag.get().value && module.filename.includes("node_modules")) {
         return true;
     }
     return module.allowclient;
@@ -434,7 +440,9 @@ declare global {
     var remapImportRequestsClientside: undefined | ClientRemapCallback[];
 }
 
-let baseController = new RequireControllerBase();
+// Shared across copies of this package, so the registered controller and rootResolvePath (set by
+//  setRequireBootRequire) are the same instance everyone reads/writes. See createSingleton.
+const baseController = createSingleton("RequireController.baseController", 1, () => new RequireControllerBase()).get();
 /** @deprecated, not needed, as this defaults to ".", which is a lot easier to reason about anyways. */
 export function setRequireBootRequire(dir: string) {
     dir = path.resolve(dir);
@@ -445,9 +453,11 @@ export function setRequireBootRequire(dir: string) {
     baseController.rootResolvePath = dir;
 }
 
-let allowAllNodeModulesFlag = false;
+// Shared across copies, so calling allowAllNodeModules() on any copy is seen by the serving
+//  controller's getIsAllowClient. See createSingleton.
+const allowAllNodeModulesFlag = createSingleton("RequireController.allowAllNodeModules", 1, () => ({ value: false }));
 export function allowAllNodeModules() {
-    allowAllNodeModulesFlag = true;
+    allowAllNodeModulesFlag.get().value = true;
 }
 
 export const RequireController = SocketFunction.register(

package/src/callManager.ts

@@ -86,7 +86,8 @@ export function registerClass(classGuid: string, controller: SocketExposedInterf
     noFunctionMeasure?: boolean;
 }) {
     if (!globalThis.isHotReloading?.() && classes[classGuid]) {
-        throw new Error(`Class ${classGuid} already registered`);
+        console.warn(`Class ${classGuid} already registered. This is normal if you are using multiple copies of socket-function at once.`);
+        return;
     }
 
     if (!config?.noFunctionMeasure) {