@caboodle-tech/node-simple-server 2.0.1 → 4.0.0

package/handlers/websocket-only.html

@@ -0,0 +1,153 @@
+<!-- Code injected by Node Simple Server. -->
+<script type="text/javascript">
+    // <![CDATA[
+    if ("WebSocket" in window) {
+        NSS_WS = (() => {
+            /** Expose the random page ID that was assigned to this page. */
+            const getId = () => {
+                return pageId;
+            };
+
+            /** Register a function or functions to call when this page receives a WebSocket message. */
+            const registerCallback = (func) => {
+                if (whatIs(func) === "function") {
+                    callbacks.push(func);
+                }
+            };
+
+            /** Attempt to reestablish a connection to the WebSocket server. */
+            const restart = () => {
+                const http = new XMLHttpRequest();
+                http.onerror = function (e) {
+                    // Ignore the error in browsers that respect that.
+                };
+                // Attempt a reconnect.
+                http.onreadystatechange = () => {
+                    if (http.readyState === 4) {
+                        if (http.status >= 200 && http.status < 400) {
+                            window.location.reload();
+                        }
+                    }
+                };
+                http.open("GET", window.location.href);
+                http.send();
+                // Keep attempting to reconnect unless told not to.
+                if (autoRestart) {
+                    if (restartAttempts < 10) {
+                        restartAttempts += 1;
+                    }
+                    clearInterval(restartInterval);
+                    restartInterval = setInterval(restart, 3000 * restartAttempts);
+                }
+            };
+
+            /** Send a WebSocket message to the WebSocket server. */
+            const send = (message) => {
+                if (ready && socket.readyState === WebSocket.OPEN) {
+                    socket.send(JSON.stringify({
+                        message,
+                        type: whatIs(message)
+                    }));
+                    return;
+                }
+                console.warn("Node Simple Server: The WebSocket is not ready or the connection was closed.");
+            };
+
+            /** Generate a random unique ID for this page; will be registered in the back-end. */
+            const uid = () => {
+                return Math.random().toString(16).slice(2);
+            };
+
+            /** Remove a callback function previously registered with registerCallback(). */
+            const unregisterCallback = (func) => {
+                for (let i = 0; i < callbacks.length; i++) {
+                    if (callbacks[i] == func) {
+                        callbacks.splice(i, 1);
+                    }
+                }
+            };
+
+            /**
+             * The fastest way to get the actual type of anything in JavaScript.
+             *
+             * {@link https://jsbench.me/ruks9jljcu/2 | See benchmarks}.
+             *
+             * @param {*} unknown Anything you wish to check the type of.
+             * @return {string|undefined} The type in lowercase of the unknown value passed in or undefined.
+             */
+            const whatIs = (unknown) => {
+                try {
+                    return ({}).toString.call(unknown).match(/\s([^\]]+)/)[1].toLowerCase();
+                } catch (e) { return undefined; }
+            };
+
+            // NSS_WS internal global variables.
+            let autoRestart = true;
+            const callbacks = [];
+            let counterInterval = null;
+            const pageId = uid();
+            let ready = false;
+            let restartAttempts = 0;
+            let restartInterval = null;
+
+            // Socket specific variables.
+            const protocol = window.location.protocol === "http:" ? "ws://" : "wss://";
+            const address = protocol + window.location.host + window.location.pathname + "/ws?id=" + pageId;
+            const socket = new WebSocket(address);
+
+            // Respond to messages the socket receives.
+            socket.onmessage = (evt) => {
+                const msgObj = JSON.parse(evt.data); // NSS uses a standard messaging object.
+                switch (msgObj.message) {
+                    case "close":
+                        ready = false;
+                        break;
+                    case "disableAutoRestart":
+                        autoRestart = false;
+                        clearInterval(restartInterval);
+                        clearInterval(counterInterval);
+                        break;
+                    case 'ping':
+                        send('pong');
+                        break;
+                    case "reload":
+                        window.location.reload();
+                        break;
+                    default:
+                        if (callbacks.length > 0) {
+                            for (let i = 0; i < callbacks.length; i++) {
+                                callbacks[i](msgObj);
+                            }
+                            return;
+                        }
+                        console.log(`Received from WebSocket: ${msgObj.message}`);
+                }
+            };
+
+            // Mark the script as not ready when the websocket connection is closed.
+            socket.addEventListener("close", () => {
+                ready = false;
+                if (autoRestart) {
+                    restartInterval = setInterval(restart, 3000);
+                }
+            });
+
+            // Mark the script as ready when a websocket connection is established.
+            socket.addEventListener("open", () => {
+                ready = true;
+            });
+
+            // Expose some of NSS_WS methods.
+            return {
+                getId,
+                registerCallback,
+                send,
+                unregisterCallback,
+                whatIs
+            };
+        })();
+    } else {
+        console.error("Node Simple Server: This Browser does NOT support WebSockets.");
+    }
+    // ]]>
+</script>

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "@caboodle-tech/node-simple-server",
-    "version": "2.0.1",
+    "version": "4.0.0",
     "description": "Node Simple Server (NSS): A small but effective node based server for development sites, customizable live reloading, and websocket support built-in.",
     "main": "bin/nss.js",
     "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1",
         "example": "node ./examples/run.js",
+        "example:production": "node ./examples/run.js production",
         "example:website": "node ./examples/run.js website",
         "example:websocket": "node ./examples/run.js websocket"
     },
@@ -22,7 +23,9 @@
         "Reloading",
         "Callback",
         "Functions",
-        "WebSocket"
+        "WebSocket",
+        "Internal",
+        "Applications"
     ],
     "author": "Christopher Keers <source[at]caboodle.tech>",
     "contributors": [