socket-function 1.1.48 → 1.2.0

package/hot/dist/HotReloadController.ts.cache

@@ -0,0 +1,252 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+exports.HotReloadController = exports.onHotReload = exports.setExternalHotReloading = exports.hotReloadingGuard = exports.isHotReloading = exports.watchFilesAndTriggerHotReloading = void 0;
+/// <reference path="../../typenode/index.d.ts" />
+/// <reference path="../require/RequireController.ts" />
+module.allowclient = true;
+const SocketFunction_1 = require("../SocketFunction");
+const caching_1 = require("../src/caching");
+const createSingleton_1 = require("../src/createSingleton");
+const fs = __importStar(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
+const misc_1 = require("../src/misc");
+const logColors_1 = require("../src/formatting/logColors");
+const format_1 = require("../src/formatting/format");
+const RequireController_1 = require("../require/RequireController");
+/** Enables some hot reload functionality.
+ *      - Triggers a refresh clientside
+ *      - Triggers a reload server, for modules marked with `module.hotreload`
+ */
+function watchFilesAndTriggerHotReloading(noAutomaticBrowserWatch = false) {
+    SocketFunction_1.SocketFunction.expose(exports.HotReloadController);
+    if (!(0, misc_1.isNode)()) {
+        if (!noAutomaticBrowserWatch) {
+            exports.HotReloadController.nodes[SocketFunction_1.SocketFunction.browserNodeId()]
+                .watchFiles()
+                .catch(e => console.error("watchFiles error", e));
+        }
+    }
+    setInterval(() => {
+        for (let module of Object.values(require.cache)) {
+            if (!module)
+                continue;
+            hotReloadModule(module);
+        }
+    }, 5000);
+}
+exports.watchFilesAndTriggerHotReloading = watchFilesAndTriggerHotReloading;
+// 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 = (0, createSingleton_1.createSingleton)("HotReloadController.isHotReloading", 1, () => ({ value: false }));
+function isHotReloading() {
+    return isHotReloadingState.get().value;
+}
+exports.isHotReloading = isHotReloading;
+globalThis.isHotReloading = isHotReloading;
+function hotReloadingGuard() {
+    return !isHotReloading();
+}
+exports.hotReloadingGuard = hotReloadingGuard;
+function setExternalHotReloading(value) {
+    isHotReloadingState.get().value = value;
+}
+exports.setExternalHotReloading = setExternalHotReloading;
+// 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 = (0, createSingleton_1.createSingleton)("HotReloadController.hotReloadCallbacks", 1, () => []).get();
+function onHotReload(callback) {
+    hotReloadCallbacks.push(callback);
+}
+exports.onHotReload = onHotReload;
+const hotReloadModule = (0, caching_1.cache)((module) => {
+    if (!module.updateContents)
+        return;
+    let interval = 1000;
+    let fast = false;
+    if (module.hotreload) {
+        interval = 100;
+        fast = true;
+    }
+    let lastHashes = new Map();
+    function getHash(path) {
+        try {
+            let contents = fs.readFileSync(path, "utf8");
+            return crypto_1.default.createHash("sha256").update(contents).digest("hex");
+        }
+        catch (_a) {
+            return "";
+        }
+    }
+    watchFile(module.filename);
+    for (let path of module.watchAdditionalFiles || []) {
+        watchFile(path);
+    }
+    function watchFile(path) {
+        lastHashes.set(path, getHash(path));
+        fs.watchFile(path, { persistent: false, interval }, (curr, prev) => {
+            let newHash = getHash(path);
+            if (newHash === lastHashes.get(path))
+                return;
+            lastHashes.set(path, newHash);
+            if (path === module.filename) {
+                console.log(`Hot reloading ${module.filename} due to change`);
+            }
+            else {
+                console.log(`Hot reloading ${module.filename} due to change in ${path}`);
+            }
+            doHotReload(curr.mtimeMs);
+        });
+    }
+    // IMPORTANT! changeTime is for benchmarking how long we took to hotreload (and nothing else)
+    function doHotReload(changeTime) {
+        var _a, _b, _c;
+        (_a = module.updateContents) === null || _a === void 0 ? void 0 : _a.call(module);
+        if ((0, misc_1.isNode)() && !module.noserverhotreload) {
+            if (module.hotreload
+                // A fairly big hack (as this could just be in a string, or something similar), but... it also VERY useful
+                || ((_b = module.moduleContents) === null || _b === void 0 ? void 0 : _b.includes("\nmodule.hotreload = true;" + "\n"))
+                || ((_c = module.moduleContents) === null || _c === void 0 ? void 0 : _c.includes("\r\nmodule.hotreload = true;" + "\r\n"))) {
+                console.log(`Serverside reloading ${module.id}`);
+                isHotReloadingState.get().value = true;
+                try {
+                    module.loaded = false;
+                    module.load(module.id);
+                }
+                catch (e) {
+                    console.error((0, logColors_1.red)(`Error hot reloading ${module.id}`));
+                    console.error(e);
+                }
+                finally {
+                    setTimeout(() => {
+                        isHotReloadingState.get().value = false;
+                    }, 1000);
+                }
+            }
+            for (let callback of hotReloadCallbacks) {
+                callback([module]);
+            }
+        }
+        //module.sourceSHA256;
+        // crypto.createHash("sha256").update(contents).digest("hex")
+        if ((0, RequireController_1.getIsAllowClient)(module)) {
+            triggerClientSideReload({
+                files: [module.filename],
+                changeTime,
+                fast,
+            });
+        }
+    }
+});
+let reloadTriggering = false;
+let clientWatcherNodes = new Set();
+let pendingTriggerFiles = new Set();
+function triggerClientSideReload(config) {
+    for (let file of config.files) {
+        pendingTriggerFiles.add(file);
+    }
+    if (reloadTriggering)
+        return;
+    reloadTriggering = true;
+    setTimeout(async () => {
+        reloadTriggering = false;
+        let files = Array.from(pendingTriggerFiles);
+        pendingTriggerFiles.clear();
+        for (let clientNodeId of clientWatcherNodes) {
+            console.log(`Notifying client of hot reload: ${clientNodeId}`, files);
+            exports.HotReloadController.nodes[clientNodeId].fileUpdated(files, config.changeTime).catch(() => {
+                console.log(`Removing erroring client: ${clientNodeId}`);
+                clientWatcherNodes.delete(clientNodeId);
+            });
+        }
+        // We need to wait, otherwise batched updates fail, WHICH, can result in updates while reloading,
+        //  which causes missed updates.
+    }, config.fast ? 50 : 300);
+}
+class HotReloadControllerBase {
+    // TODO: Also hot reload when we reconnect to the server, as it is likely setup will need to
+    //  be rerun in that case as well (for example, we need to call watchFiles again!)
+    async watchFiles() {
+        let callerId = SocketFunction_1.SocketFunction.getCaller().nodeId;
+        clientWatcherNodes.add(callerId);
+    }
+    // TODO: This is actually broken related to lazy loaded and server-only code, as the server will tell us a file changed, and then we'll see that we don't have it loaded, and so we will try to refresh.
+    //      - The reason we refresh is because it might be a new file. I don't know how we could check to see if it was lazy loaded. Maybe we just shouldn't refresh ever if we can't find the module? We'll see how much we run into the extra refresh due to lazy loading...
+    async fileUpdated(files, changeTime) {
+        try {
+            console.groupCollapsed((0, logColors_1.magenta)(`Trigger hotreload for files ${(0, format_1.formatTime)(Date.now() - changeTime)} after file change`));
+            for (let file of files) {
+                console.log(file);
+            }
+            console.groupEnd();
+            let modules = [];
+            for (let file of files) {
+                file = "https://" + ((BOOTED_EDGE_NODE === null || BOOTED_EDGE_NODE === void 0 ? void 0 : BOOTED_EDGE_NODE.host) || location.host) + "/" + file;
+                let module = require.cache[file];
+                if (!module) {
+                    console.log(`Module not found: ${file}, not reloading page`);
+                    return;
+                }
+                if (!module.hotreload) {
+                    console.log(`Module not hotreloadable: ${file}, reloading page to ensure new version is loaded`);
+                    document.location.reload();
+                    return;
+                }
+                modules.push(module);
+            }
+            for (let module of modules) {
+                module.loaded = false;
+            }
+            isHotReloadingState.get().value = true;
+            try {
+                await Promise.all(modules.map(module => module.load(module.filename)));
+            }
+            finally {
+                setTimeout(() => {
+                    isHotReloadingState.get().value = false;
+                }, 1000);
+            }
+            for (let callback of hotReloadCallbacks) {
+                callback(modules);
+            }
+            console.log((0, logColors_1.magenta)(`Hot reload complete ${(0, format_1.formatTime)(Date.now() - changeTime)} after file change`));
+        }
+        catch (e) {
+            console.error(`Hot reload failed ${e.stack}`);
+        }
+    }
+}
+exports.HotReloadController = SocketFunction_1.SocketFunction.register("HotReloadController-032b2250-3aac-4187-8c95-75412742b8f5", new HotReloadControllerBase(), () => ({
+    watchFiles: {},
+    fileUpdated: {}
+}), () => ({}), {
+    noAutoExpose: true,
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"HotReloadController.js","sourceRoot":"","sources":["HotReloadController.ts"],"names":[],"mappings":"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","sourcesContent":["/// <reference path=\"../../typenode/index.d.ts\" />\n/// <reference path=\"../require/RequireController.ts\" />\nmodule.allowclient = true;\n\nimport { SocketFunction } from \"../SocketFunction\";\nimport { cache, lazy } from \"../src/caching\";\nimport { createSingleton } from \"../src/createSingleton\";\nimport * as fs from \"fs\";\nimport crypto from \"crypto\";\nimport debugbreak from \"debugbreak\";\nimport { isNode } from \"../src/misc\";\nimport { magenta, red } from \"../src/formatting/logColors\";\nimport { formatTime } from \"../src/formatting/format\";\nimport { batchFunction } from \"../src/batching\";\nimport { getIsAllowClient } from \"../require/RequireController\";\n\n/** Enables some hot reload functionality.\n *      - Triggers a refresh clientside\n *      - Triggers a reload server, for modules marked with `module.hotreload`\n */\nexport function watchFilesAndTriggerHotReloading(noAutomaticBrowserWatch = false) {\n    SocketFunction.expose(HotReloadController);\n    if (!isNode()) {\n        if (!noAutomaticBrowserWatch) {\n            HotReloadController.nodes[SocketFunction.browserNodeId()]\n                .watchFiles()\n                .catch(e => console.error(\"watchFiles error\", e))\n                ;\n        }\n    }\n    setInterval(() => {\n        for (let module of Object.values(require.cache)) {\n            if (!module) continue;\n            hotReloadModule(module);\n        }\n    }, 5000);\n}\n\ndeclare global {\n    namespace NodeJS {\n        interface Module {\n            /** Causes us to hotreload the file. Applies both serverside and clientside.\n             *      - If not set for any files clientside, we will refresh.\n             *      - If not set for any files serverside, we will do nothing (and just leave old code running).\n             */\n            hotreload?: boolean;\n            /** Overrides hotreload to disable hot reloading. Useful if you add \"hotreload.flag\" to a directory\n             *      (which sets hotreload on all files in and under that directory), but want a specific file\n             *      to not hotreload.\n             *  - Also useful if you want files to hotreload clientside, but not serverside.\n             */\n            noserverhotreload?: boolean;\n\n            watchAdditionalFiles?: string[];\n        }\n    }\n    var isHotReloading: (() => boolean) | undefined;\n}\n\n// Shared across copies of this package, so the \"currently hot reloading\" flag is consistent no\n//  matter which copy set it (ex, setExternalHotReloading) or reads it (callManager.registerClass\n//  reads it via the globalThis.isHotReloading bridge, which each copy overwrites). See createSingleton.\nconst isHotReloadingState = createSingleton(\"HotReloadController.isHotReloading\", 1, () => ({ value: false }));\nexport function isHotReloading() {\n    return isHotReloadingState.get().value;\n}\nglobalThis.isHotReloading = isHotReloading;\nexport function hotReloadingGuard(): true {\n    return !isHotReloading() as any;\n}\nexport function setExternalHotReloading(value: boolean) {\n    isHotReloadingState.get().value = value;\n}\n// Shared across copies, so callbacks registered through one copy's onHotReload still fire when the\n//  first-registered copy's controller performs a reload. See createSingleton.\nconst hotReloadCallbacks = createSingleton(\"HotReloadController.hotReloadCallbacks\", 1, () => [] as ((modules: NodeJS.Module[]) => void)[]).get();\nexport function onHotReload(callback: (modules: NodeJS.Module[]) => void) {\n    hotReloadCallbacks.push(callback);\n}\n\nconst hotReloadModule = cache((module: NodeJS.Module) => {\n    if (!module.updateContents) return;\n    let interval = 1000;\n    let fast = false;\n    if (module.hotreload) {\n        interval = 100;\n        fast = true;\n    }\n\n    let lastHashes = new Map<string, string>();\n    function getHash(path: string) {\n        try {\n            let contents = fs.readFileSync(path, \"utf8\");\n            return crypto.createHash(\"sha256\").update(contents).digest(\"hex\");\n        } catch {\n            return \"\";\n        }\n    }\n\n    watchFile(module.filename);\n    for (let path of module.watchAdditionalFiles || []) {\n        watchFile(path);\n    }\n\n    function watchFile(path: string) {\n        lastHashes.set(path, getHash(path));\n        fs.watchFile(path, { persistent: false, interval }, (curr, prev) => {\n            let newHash = getHash(path);\n            if (newHash === lastHashes.get(path)) return;\n            lastHashes.set(path, newHash);\n            if (path === module.filename) {\n                console.log(`Hot reloading ${module.filename} due to change`);\n            } else {\n                console.log(`Hot reloading ${module.filename} due to change in ${path}`);\n            }\n            doHotReload(curr.mtimeMs);\n        });\n    }\n\n\n\n    // IMPORTANT! changeTime is for benchmarking how long we took to hotreload (and nothing else)\n    function doHotReload(changeTime: number) {\n        module.updateContents?.();\n        if (isNode() && !module.noserverhotreload) {\n            if (\n                module.hotreload\n                // A fairly big hack (as this could just be in a string, or something similar), but... it also VERY useful\n                || module.moduleContents?.includes(\"\\nmodule.hotreload = true;\" + \"\\n\")\n                || module.moduleContents?.includes(\"\\r\\nmodule.hotreload = true;\" + \"\\r\\n\")\n            ) {\n                console.log(`Serverside reloading ${module.id}`);\n                isHotReloadingState.get().value = true;\n                try {\n                    module.loaded = false;\n                    module.load(module.id);\n                } catch (e) {\n                    console.error(red(`Error hot reloading ${module.id}`));\n                    console.error(e);\n                } finally {\n                    setTimeout(() => {\n                        isHotReloadingState.get().value = false;\n                    }, 1000);\n                }\n            }\n            for (let callback of hotReloadCallbacks) {\n                callback([module]);\n            }\n        }\n        //module.sourceSHA256;\n        // crypto.createHash(\"sha256\").update(contents).digest(\"hex\")\n        if (getIsAllowClient(module)) {\n            triggerClientSideReload({\n                files: [module.filename],\n                changeTime,\n                fast,\n            });\n        }\n    }\n});\nlet reloadTriggering = false;\nlet clientWatcherNodes = new Set<string>();\nlet pendingTriggerFiles = new Set<string>();\nfunction triggerClientSideReload(config: {\n    files: string[];\n    changeTime: number;\n    fast?: boolean;\n}) {\n    for (let file of config.files) {\n        pendingTriggerFiles.add(file);\n    }\n    if (reloadTriggering) return;\n    reloadTriggering = true;\n    setTimeout(async () => {\n        reloadTriggering = false;\n        let files = Array.from(pendingTriggerFiles);\n        pendingTriggerFiles.clear();\n        for (let clientNodeId of clientWatcherNodes) {\n            console.log(`Notifying client of hot reload: ${clientNodeId}`, files);\n            HotReloadController.nodes[clientNodeId].fileUpdated(files, config.changeTime).catch(() => {\n                console.log(`Removing erroring client: ${clientNodeId}`);\n                clientWatcherNodes.delete(clientNodeId);\n            });\n        }\n        // We need to wait, otherwise batched updates fail, WHICH, can result in updates while reloading,\n        //  which causes missed updates.\n    }, config.fast ? 50 : 300);\n}\n\nclass HotReloadControllerBase {\n    // TODO: Also hot reload when we reconnect to the server, as it is likely setup will need to\n    //  be rerun in that case as well (for example, we need to call watchFiles again!)\n    async watchFiles() {\n        let callerId = SocketFunction.getCaller().nodeId;\n        clientWatcherNodes.add(callerId);\n    }\n    // TODO: This is actually broken related to lazy loaded and server-only code, as the server will tell us a file changed, and then we'll see that we don't have it loaded, and so we will try to refresh.\n    //      - The reason we refresh is because it might be a new file. I don't know how we could check to see if it was lazy loaded. Maybe we just shouldn't refresh ever if we can't find the module? We'll see how much we run into the extra refresh due to lazy loading...\n    async fileUpdated(files: string[], changeTime: number) {\n        try {\n            console.groupCollapsed(magenta(`Trigger hotreload for files ${formatTime(Date.now() - changeTime)} after file change`));\n            for (let file of files) {\n                console.log(file);\n            }\n            console.groupEnd();\n            let modules: NodeJS.Module[] = [];\n            for (let file of files) {\n                file = \"https://\" + (BOOTED_EDGE_NODE?.host || location.host) + \"/\" + file;\n                let module = require.cache[file];\n                if (!module) {\n                    console.log(`Module not found: ${file}, not reloading page`);\n                    return;\n                }\n                if (!module.hotreload) {\n                    console.log(`Module not hotreloadable: ${file}, reloading page to ensure new version is loaded`);\n                    document.location.reload();\n                    return;\n                }\n                modules.push(module);\n            }\n            for (let module of modules) {\n                module.loaded = false;\n            }\n            isHotReloadingState.get().value = true;\n            try {\n                await Promise.all(modules.map(module => module.load(module.filename)));\n            } finally {\n                setTimeout(() => {\n                    isHotReloadingState.get().value = false;\n                }, 1000);\n            }\n\n            for (let callback of hotReloadCallbacks) {\n                callback(modules);\n            }\n            console.log(magenta(`Hot reload complete ${formatTime(Date.now() - changeTime)} after file change`));\n        } catch (e: any) {\n            console.error(`Hot reload failed ${e.stack}`);\n        }\n    }\n}\n\nexport const HotReloadController = SocketFunction.register(\n    \"HotReloadController-032b2250-3aac-4187-8c95-75412742b8f5\",\n    new HotReloadControllerBase(),\n    () => ({\n        watchFiles: {},\n        fileUpdated: {}\n    }),\n    () => ({\n\n    }),\n    {\n        noAutoExpose: true,\n    }\n);"]}
+ /* _JS_SOURCE_HASH = "fad5234ef4614a67e7686e156e1de47b8cb72f9f93a3c3e4945c518e41eff353"; */

package/package.json

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