@jsenv/core 36.2.1 → 36.3.0

package/dist/js/ribbon.js

@@ -1,7 +1,5 @@
-const injectRibbon = ({
-  text
-}) => {
-  const css = /* css */`
+const injectRibbon = ({ text }) => {
+  const css = /* css */ `
       #jsenv_ribbon_container {
         position: absolute;
         z-index: 1001;
@@ -39,15 +37,22 @@ const injectRibbon = ({
         user-select: none;
       }
     `;
-  const html = /* html */`<div id="jsenv_ribbon_container">
+
+  const html = /* html */ `<div id="jsenv_ribbon_container">
       <style>${css}</style>
       <div id="jsenv_ribbon">
         <div id="jsenv_ribbon_text">${text}</div>
       </div>
     </div>`;
+
   const node = document.createElement("div");
   node.innerHTML = html;
-  const toolbarStateInLocalStorage = localStorage.hasOwnProperty("jsenv_toolbar") ? JSON.parse(localStorage.getItem("jsenv_toolbar")) : {};
+
+  const toolbarStateInLocalStorage = localStorage.hasOwnProperty(
+    "jsenv_toolbar",
+  )
+    ? JSON.parse(localStorage.getItem("jsenv_toolbar"))
+    : {};
   if (toolbarStateInLocalStorage.ribbonDisplayed === false) {
     node.querySelector("#jsenv_ribbon_container").style.display = "none";
   }

package/dist/js/server_events_client.js

@@ -2,30 +2,34 @@ const READY_STATES = {
   CONNECTING: "connecting",
   OPEN: "open",
   CLOSING: "closing",
-  CLOSED: "closed"
+  CLOSED: "closed",
 };
-const createConnectionManager = (attemptConnection, {
-  retry,
-  retryAfter,
-  retryMaxAttempt,
-  retryAllocatedMs
-}) => {
+
+const createConnectionManager = (
+  attemptConnection,
+  { retry, retryAfter, retryMaxAttempt, retryAllocatedMs },
+) => {
   const readyState = {
     value: READY_STATES.CLOSED,
-    goTo: value => {
+    goTo: (value) => {
       if (value === readyState.value) {
         return;
       }
       readyState.value = value;
       readyState.onchange();
     },
-    onchange: () => {}
+    onchange: () => {},
   };
+
   let _disconnect = () => {};
   const connect = () => {
-    if (readyState.value === READY_STATES.CONNECTING || readyState.value === READY_STATES.OPEN) {
+    if (
+      readyState.value === READY_STATES.CONNECTING ||
+      readyState.value === READY_STATES.OPEN
+    ) {
       return;
     }
+
     let retryCount = 0;
     let msSpent = 0;
     const attempt = () => {
@@ -40,12 +44,16 @@ const createConnectionManager = (attemptConnection, {
           }
           if (retryCount > retryMaxAttempt) {
             readyState.goTo(READY_STATES.CLOSED);
-            console.info(`[jsenv] could not connect to server after ${retryMaxAttempt} attempt`);
+            console.info(
+              `[jsenv] could not connect to server after ${retryMaxAttempt} attempt`,
+            );
             return;
           }
           if (retryAllocatedMs && msSpent > retryAllocatedMs) {
             readyState.goTo(READY_STATES.CLOSED);
-            console.info(`[jsenv] could not connect to server in less than ${retryAllocatedMs}ms`);
+            console.info(
+              `[jsenv] could not connect to server in less than ${retryAllocatedMs}ms`,
+            );
             return;
           }
           // if closed while open -> connection lost
@@ -63,9 +71,8 @@ const createConnectionManager = (attemptConnection, {
         onOpen: () => {
           readyState.goTo(READY_STATES.OPEN);
           // console.info(`[jsenv] connected to server`)
-        }
+        },
       });
-
       _disconnect = () => {
         cancelAttempt();
         clearTimeout(timeout);
@@ -74,18 +81,29 @@ const createConnectionManager = (attemptConnection, {
     };
     attempt();
   };
+
   const disconnect = () => {
-    if (readyState.value !== READY_STATES.CONNECTING && readyState.value !== READY_STATES.OPEN) {
-      console.warn(`disconnect() ignored because connection is ${readyState.value}`);
+    if (
+      readyState.value !== READY_STATES.CONNECTING &&
+      readyState.value !== READY_STATES.OPEN
+    ) {
+      console.warn(
+        `disconnect() ignored because connection is ${readyState.value}`,
+      );
       return null;
     }
     return _disconnect();
   };
+
   const removePageUnloadListener = listenPageUnload(() => {
-    if (readyState.value === READY_STATES.CONNECTING || readyState.value === READY_STATES.OPEN) {
+    if (
+      readyState.value === READY_STATES.CONNECTING ||
+      readyState.value === READY_STATES.OPEN
+    ) {
       _disconnect();
     }
   });
+
   return {
     readyState,
     connect,
@@ -93,7 +111,7 @@ const createConnectionManager = (attemptConnection, {
     destroy: () => {
       removePageUnloadListener();
       disconnect();
-    }
+    },
   };
 };
 
@@ -131,14 +149,19 @@ const createConnectionManager = (attemptConnection, {
 //   }
 // }
 
-const listenPageUnload = callback => {
-  const removePageHideListener = listenEvent(window, "pagehide", pageHideEvent => {
-    if (pageHideEvent.persisted !== true) {
-      callback(pageHideEvent);
-    }
-  });
+const listenPageUnload = (callback) => {
+  const removePageHideListener = listenEvent(
+    window,
+    "pagehide",
+    (pageHideEvent) => {
+      if (pageHideEvent.persisted !== true) {
+        callback(pageHideEvent);
+      }
+    },
+  );
   return removePageHideListener;
 };
+
 const listenEvent = (emitter, event, callback) => {
   emitter.addEventListener(event, callback);
   return () => {
@@ -146,14 +169,12 @@ const listenEvent = (emitter, event, callback) => {
   };
 };
 
-const createEventsManager = ({
-  effect = () => {}
-} = {}) => {
+const createEventsManager = ({ effect = () => {} } = {}) => {
   const callbacksMap = new Map();
   let cleanup;
-  const addCallbacks = namedCallbacks => {
+  const addCallbacks = (namedCallbacks) => {
     let callbacksMapSize = callbacksMap.size;
-    Object.keys(namedCallbacks).forEach(eventName => {
+    Object.keys(namedCallbacks).forEach((eventName) => {
       const callback = namedCallbacks[eventName];
       const existingCallbacks = callbacksMap.get(eventName);
       let callbacks;
@@ -168,12 +189,13 @@ const createEventsManager = ({
     if (effect && callbacksMapSize === 0 && callbacksMapSize.size > 0) {
       cleanup = effect();
     }
+
     let removed = false;
     return () => {
       if (removed) return;
       removed = true;
       callbacksMapSize = callbacksMap.size;
-      Object.keys(namedCallbacks).forEach(eventName => {
+      Object.keys(namedCallbacks).forEach((eventName) => {
         const callback = namedCallbacks[eventName];
         const callbacks = callbacksMap.get(eventName);
         if (callbacks) {
@@ -187,20 +209,27 @@ const createEventsManager = ({
         }
       });
       namedCallbacks = null; // allow garbage collect
-      if (cleanup && typeof cleanup === "function" && callbacksMapSize > 0 && callbacksMapSize.size === 0) {
+      if (
+        cleanup &&
+        typeof cleanup === "function" &&
+        callbacksMapSize > 0 &&
+        callbacksMapSize.size === 0
+      ) {
         cleanup();
         cleanup = null;
       }
     };
   };
-  const triggerCallbacks = event => {
+
+  const triggerCallbacks = (event) => {
     const callbacks = callbacksMap.get(event.type);
     if (callbacks) {
-      callbacks.forEach(callback => {
+      callbacks.forEach((callback) => {
         callback(event);
       });
     }
   };
+
   const destroy = () => {
     callbacksMap.clear();
     if (cleanup) {
@@ -208,68 +237,67 @@ const createEventsManager = ({
       cleanup = null;
     }
   };
+
   return {
     addCallbacks,
     triggerCallbacks,
-    destroy
+    destroy,
   };
 };
 
-const createWebSocketConnection = (websocketUrl, {
-  protocols = ["jsenv"],
-  useEventsToManageConnection = true,
-  retry = false,
-  retryAfter = 1000,
-  retryMaxAttempt = Infinity,
-  retryAllocatedMs = Infinity
-} = {}) => {
-  const connectionManager = createConnectionManager(({
-    onClosed,
-    onOpen
-  }) => {
-    let socket = new WebSocket(websocketUrl, protocols);
-    let interval;
-    const cleanup = () => {
-      if (socket) {
-        socket.onerror = null;
+const createWebSocketConnection = (
+  websocketUrl,
+  {
+    protocols = ["jsenv"],
+    useEventsToManageConnection = true,
+    retry = false,
+    retryAfter = 1000,
+    retryMaxAttempt = Infinity,
+    retryAllocatedMs = Infinity,
+  } = {},
+) => {
+  const connectionManager = createConnectionManager(
+    ({ onClosed, onOpen }) => {
+      let socket = new WebSocket(websocketUrl, protocols);
+      let interval;
+      const cleanup = () => {
+        if (socket) {
+          socket.onerror = null;
+          socket.onopen = null;
+          socket.onclose = null;
+          socket.onmessage = null;
+          socket = null;
+          clearInterval(interval);
+        }
+      };
+      socket.onerror = () => {
+        cleanup();
+        onClosed();
+      };
+      socket.onopen = () => {
         socket.onopen = null;
-        socket.onclose = null;
-        socket.onmessage = null;
-        socket = null;
-        clearInterval(interval);
-      }
-    };
-    socket.onerror = () => {
-      cleanup();
-      onClosed();
-    };
-    socket.onopen = () => {
-      socket.onopen = null;
-      onOpen();
-      interval = setInterval(() => {
-        socket.send('{"type":"ping"}');
-      }, 30_000);
-    };
-    socket.onclose = () => {
-      cleanup();
-      onClosed();
-    };
-    socket.onmessage = messageEvent => {
-      const event = JSON.parse(messageEvent.data);
-      eventsManager.triggerCallbacks(event);
-    };
-    return () => {
-      if (socket) {
-        socket.close();
+        onOpen();
+        interval = setInterval(() => {
+          socket.send('{"type":"ping"}');
+        }, 30_000);
+      };
+      socket.onclose = () => {
         cleanup();
-      }
-    };
-  }, {
-    retry,
-    retryAfter,
-    retryMaxAttempt,
-    retryAllocatedMs
-  });
+        onClosed();
+      };
+      socket.onmessage = (messageEvent) => {
+        const event = JSON.parse(messageEvent.data);
+        eventsManager.triggerCallbacks(event);
+      };
+      return () => {
+        if (socket) {
+          socket.close();
+          cleanup();
+        }
+      };
+    },
+    { retry, retryAfter, retryMaxAttempt, retryAllocatedMs },
+  );
   const eventsManager = createEventsManager({
     effect: () => {
       if (useEventsToManageConnection) {
@@ -279,19 +307,20 @@ const createWebSocketConnection = (websocketUrl, {
         };
       }
       return null;
-    }
+    },
   });
+
   return {
     readyState: connectionManager.readyState,
     connect: connectionManager.connect,
     disconnect: connectionManager.disconnect,
-    listenEvents: namedCallbacks => {
+    listenEvents: (namedCallbacks) => {
       return eventsManager.addCallbacks(namedCallbacks);
     },
     destroy: () => {
       connectionManager.destroy();
       eventsManager.destroy();
-    }
+    },
   };
 };
 
@@ -299,18 +328,13 @@ const websocketScheme = self.location.protocol === "https:" ? "wss" : "ws";
 const websocketUrl = `${websocketScheme}://${self.location.host}${self.location.pathname}${self.location.search}`;
 const websocketConnection = createWebSocketConnection(websocketUrl, {
   retry: true,
-  retryAllocatedMs: 10_000
+  retryAllocatedMs: 10_000,
 });
-const {
-  readyState,
-  connect,
-  disconnect,
-  listenEvents
-} = websocketConnection;
+const { readyState, connect, disconnect, listenEvents } = websocketConnection;
 window.__server_events__ = {
   readyState,
   connect,
   disconnect,
-  listenEvents
+  listenEvents,
 };
 connect();