@jsenv/core 35.0.3 → 35.0.5

package/src/plugins/server_events/client/connection_manager.js

@@ -3,7 +3,7 @@ const READY_STATES = {
   OPEN: "open",
   CLOSING: "closing",
   CLOSED: "closed",
-}
+};
 
 export const createConnectionManager = (
   attemptConnection,
@@ -13,74 +13,74 @@ export const createConnectionManager = (
     value: READY_STATES.CLOSED,
     goTo: (value) => {
       if (value === readyState.value) {
-        return
+        return;
       }
-      readyState.value = value
-      readyState.onchange()
+      readyState.value = value;
+      readyState.onchange();
     },
     onchange: () => {},
-  }
+  };
 
-  let _disconnect = () => {}
+  let _disconnect = () => {};
   const connect = () => {
     if (
       readyState.value === READY_STATES.CONNECTING ||
       readyState.value === READY_STATES.OPEN
     ) {
-      return
+      return;
     }
 
-    let retryCount = 0
-    let msSpent = 0
+    let retryCount = 0;
+    let msSpent = 0;
     const attempt = () => {
-      readyState.goTo(READY_STATES.CONNECTING)
-      let timeout
+      readyState.goTo(READY_STATES.CONNECTING);
+      let timeout;
       const cancelAttempt = attemptConnection({
         onClosed: () => {
           if (!retry) {
-            readyState.goTo(READY_STATES.CLOSED)
-            console.info(`[jsenv] failed to connect to server`)
-            return
+            readyState.goTo(READY_STATES.CLOSED);
+            console.info(`[jsenv] failed to connect to server`);
+            return;
           }
           if (retryCount > retryMaxAttempt) {
-            readyState.goTo(READY_STATES.CLOSED)
+            readyState.goTo(READY_STATES.CLOSED);
             console.info(
               `[jsenv] could not connect to server after ${retryMaxAttempt} attempt`,
-            )
-            return
+            );
+            return;
           }
           if (retryAllocatedMs && msSpent > retryAllocatedMs) {
-            readyState.goTo(READY_STATES.CLOSED)
+            readyState.goTo(READY_STATES.CLOSED);
             console.info(
               `[jsenv] could not connect to server in less than ${retryAllocatedMs}ms`,
-            )
-            return
+            );
+            return;
           }
           // if closed while open -> connection lost
           // otherwise it's the attempt to connect for the first time
           // or to reconnect
           if (readyState.value === READY_STATES.OPEN) {
-            console.info(`[jsenv] server connection lost; retrying to connect`)
+            console.info(`[jsenv] server connection lost; retrying to connect`);
           }
-          retryCount++
+          retryCount++;
           timeout = setTimeout(() => {
-            msSpent += retryAfter
-            attempt()
-          }, retryAfter)
+            msSpent += retryAfter;
+            attempt();
+          }, retryAfter);
         },
         onOpen: () => {
-          readyState.goTo(READY_STATES.OPEN)
+          readyState.goTo(READY_STATES.OPEN);
           // console.info(`[jsenv] connected to server`)
         },
-      })
+      });
       _disconnect = () => {
-        cancelAttempt()
-        clearTimeout(timeout)
-        readyState.goTo(READY_STATES.CLOSED)
-      }
-    }
-    attempt()
-  }
+        cancelAttempt();
+        clearTimeout(timeout);
+        readyState.goTo(READY_STATES.CLOSED);
+      };
+    };
+    attempt();
+  };
 
   const disconnect = () => {
     if (
@@ -89,31 +89,31 @@ export const createConnectionManager = (
     ) {
       console.warn(
         `disconnect() ignored because connection is ${readyState.value}`,
-      )
-      return null
+      );
+      return null;
     }
-    return _disconnect()
-  }
+    return _disconnect();
+  };
 
   const removePageUnloadListener = listenPageUnload(() => {
     if (
       readyState.value === READY_STATES.CONNECTING ||
       readyState.value === READY_STATES.OPEN
     ) {
-      _disconnect()
+      _disconnect();
     }
-  })
+  });
 
   return {
     readyState,
     connect,
     disconnect,
     destroy: () => {
-      removePageUnloadListener()
-      disconnect()
+      removePageUnloadListener();
+      disconnect();
     },
-  }
-}
+  };
+};
 
 // const listenPageMightFreeze = (callback) => {
 //   const removePageHideListener = listenEvent(window, "pagehide", (pageHideEvent) => {
@@ -155,16 +155,16 @@ const listenPageUnload = (callback) => {
     "pagehide",
     (pageHideEvent) => {
       if (pageHideEvent.persisted !== true) {
-        callback(pageHideEvent)
+        callback(pageHideEvent);
       }
     },
-  )
-  return removePageHideListener
-}
+  );
+  return removePageHideListener;
+};
 
 const listenEvent = (emitter, event, callback) => {
-  emitter.addEventListener(event, callback)
+  emitter.addEventListener(event, callback);
   return () => {
-    emitter.removeEventListener(event, callback)
-  }
-}
+    emitter.removeEventListener(event, callback);
+  };
+};

package/src/plugins/server_events/client/event_source_connection.js

@@ -1,5 +1,5 @@
-import { createConnectionManager } from "./connection_manager.js"
-import { createEventsManager } from "./events_manager.js"
+import { createConnectionManager } from "./connection_manager.js";
+import { createEventsManager } from "./events_manager.js";
 
 export const createEventSourceConnection = (
   eventSourceUrl,
@@ -12,72 +12,72 @@ export const createEventSourceConnection = (
     retryAllocatedMs = Infinity,
   } = {},
 ) => {
-  const eventSourceOrigin = new URL(eventSourceUrl).origin
+  const eventSourceOrigin = new URL(eventSourceUrl).origin;
   const attemptConnection = ({ onOpen, onClosed }) => {
     const url = lastEventId
       ? addLastEventIdIntoUrlSearchParams(eventSourceUrl, lastEventId)
-      : eventSourceUrl
-    let eventSource = new EventSource(url, { withCredentials })
+      : eventSourceUrl;
+    let eventSource = new EventSource(url, { withCredentials });
     eventSource.onerror = () => {
-      eventSource.onerror = null
-      eventSource.onopen = null
-      eventSource.onmessage = null
-      eventSource = null
-      onClosed()
-    }
+      eventSource.onerror = null;
+      eventSource.onopen = null;
+      eventSource.onmessage = null;
+      eventSource = null;
+      onClosed();
+    };
     eventSource.onopen = () => {
-      eventSource.onopen = null
-      onOpen()
-    }
+      eventSource.onopen = null;
+      onOpen();
+    };
     eventSource.onmessage = (messageEvent) => {
       if (messageEvent.origin === eventSourceOrigin) {
         if (messageEvent.lastEventId) {
-          lastEventId = messageEvent.lastEventId
+          lastEventId = messageEvent.lastEventId;
         }
-        const event = JSON.parse(messageEvent.data)
-        eventsManager.triggerCallbacks(event)
+        const event = JSON.parse(messageEvent.data);
+        eventsManager.triggerCallbacks(event);
       }
-    }
+    };
     return () => {
       if (eventSource) {
-        eventSource.close()
+        eventSource.close();
       }
-    }
-  }
+    };
+  };
   const connectionManager = createConnectionManager(attemptConnection, {
     retry,
     retryMaxAttempt,
     retryAllocatedMs,
-  })
+  });
   const eventsManager = createEventsManager({
     effect: () => {
       if (useEventsToManageConnection) {
-        connectionManager.connect()
+        connectionManager.connect();
         return () => {
-          connectionManager.disconnect()
-        }
+          connectionManager.disconnect();
+        };
       }
-      return null
+      return null;
     },
-  })
+  });
 
   return {
     readyState: connectionManager.readyState,
     listenEvents: (namedCallbacks) => {
-      return eventsManager.addCallbacks(namedCallbacks)
+      return eventsManager.addCallbacks(namedCallbacks);
     },
     destroy: () => {
-      connectionManager.destroy()
-      eventsManager.destroy()
+      connectionManager.destroy();
+      eventsManager.destroy();
     },
-  }
-}
+  };
+};
 
 const addLastEventIdIntoUrlSearchParams = (url, lastEventId) => {
   if (url.indexOf("?") === -1) {
-    url += "?"
+    url += "?";
   } else {
-    url += "&"
+    url += "&";
   }
-  return `${url}last-event-id=${encodeURIComponent(lastEventId)}`
-}
+  return `${url}last-event-id=${encodeURIComponent(lastEventId)}`;
+};

package/src/plugins/server_events/client/events_manager.js

@@ -1,75 +1,75 @@
 export const createEventsManager = ({ effect = () => {} } = {}) => {
-  const callbacksMap = new Map()
-  let cleanup
+  const callbacksMap = new Map();
+  let cleanup;
   const addCallbacks = (namedCallbacks) => {
-    let callbacksMapSize = callbacksMap.size
+    let callbacksMapSize = callbacksMap.size;
     Object.keys(namedCallbacks).forEach((eventName) => {
-      const callback = namedCallbacks[eventName]
-      const existingCallbacks = callbacksMap.get(eventName)
-      let callbacks
+      const callback = namedCallbacks[eventName];
+      const existingCallbacks = callbacksMap.get(eventName);
+      let callbacks;
       if (existingCallbacks) {
-        callbacks = existingCallbacks
+        callbacks = existingCallbacks;
       } else {
-        callbacks = []
-        callbacksMap.set(eventName, callbacks)
+        callbacks = [];
+        callbacksMap.set(eventName, callbacks);
       }
-      callbacks.push(callback)
-    })
+      callbacks.push(callback);
+    });
     if (effect && callbacksMapSize === 0 && callbacksMapSize.size > 0) {
-      cleanup = effect()
+      cleanup = effect();
     }
 
-    let removed = false
+    let removed = false;
     return () => {
-      if (removed) return
-      removed = true
-      callbacksMapSize = callbacksMap.size
+      if (removed) return;
+      removed = true;
+      callbacksMapSize = callbacksMap.size;
       Object.keys(namedCallbacks).forEach((eventName) => {
-        const callback = namedCallbacks[eventName]
-        const callbacks = callbacksMap.get(eventName)
+        const callback = namedCallbacks[eventName];
+        const callbacks = callbacksMap.get(eventName);
         if (callbacks) {
-          const index = callbacks.indexOf(callback)
+          const index = callbacks.indexOf(callback);
           if (index > -1) {
-            callbacks.splice(index, 1)
+            callbacks.splice(index, 1);
             if (callbacks.length === 0) {
-              callbacksMap.delete(eventName)
+              callbacksMap.delete(eventName);
             }
           }
         }
-      })
-      namedCallbacks = null // allow garbage collect
+      });
+      namedCallbacks = null; // allow garbage collect
       if (
         cleanup &&
         typeof cleanup === "function" &&
         callbacksMapSize > 0 &&
         callbacksMapSize.size === 0
       ) {
-        cleanup()
-        cleanup = null
+        cleanup();
+        cleanup = null;
       }
-    }
-  }
+    };
+  };
 
   const triggerCallbacks = (event) => {
-    const callbacks = callbacksMap.get(event.type)
+    const callbacks = callbacksMap.get(event.type);
     if (callbacks) {
       callbacks.forEach((callback) => {
-        callback(event)
-      })
+        callback(event);
+      });
     }
-  }
+  };
 
   const destroy = () => {
-    callbacksMap.clear()
+    callbacksMap.clear();
     if (cleanup) {
-      cleanup()
-      cleanup = null
+      cleanup();
+      cleanup = null;
     }
-  }
+  };
 
   return {
     addCallbacks,
     triggerCallbacks,
     destroy,
-  }
-}
+  };
+};

package/src/plugins/server_events/client/server_events_client.js

@@ -1,16 +1,16 @@
-import { createWebSocketConnection } from "./web_socket_connection.js"
+import { createWebSocketConnection } from "./web_socket_connection.js";
 
-const websocketScheme = self.location.protocol === "https:" ? "wss" : "ws"
-const websocketUrl = `${websocketScheme}://${self.location.host}${self.location.pathname}${self.location.search}`
+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,
-})
-const { readyState, connect, disconnect, listenEvents } = websocketConnection
+});
+const { readyState, connect, disconnect, listenEvents } = websocketConnection;
 window.__server_events__ = {
   readyState,
   connect,
   disconnect,
   listenEvents,
-}
-connect()
+};
+connect();

package/src/plugins/server_events/client/web_socket_connection.js

@@ -1,5 +1,5 @@
-import { createConnectionManager } from "./connection_manager.js"
-import { createEventsManager } from "./events_manager.js"
+import { createConnectionManager } from "./connection_manager.js";
+import { createEventsManager } from "./events_manager.js";
 
 export const createWebSocketConnection = (
   websocketUrl,
@@ -14,68 +14,68 @@ export const createWebSocketConnection = (
 ) => {
   const connectionManager = createConnectionManager(
     ({ onClosed, onOpen }) => {
-      let socket = new WebSocket(websocketUrl, protocols)
-      let interval
+      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 = null;
+          socket.onopen = null;
+          socket.onclose = null;
+          socket.onmessage = null;
+          socket = null;
+          clearInterval(interval);
         }
-      }
+      };
       socket.onerror = () => {
-        cleanup()
-        onClosed()
-      }
+        cleanup();
+        onClosed();
+      };
       socket.onopen = () => {
-        socket.onopen = null
-        onOpen()
+        socket.onopen = null;
+        onOpen();
         interval = setInterval(() => {
-          socket.send('{"type":"ping"}')
-        }, 30_000)
-      }
+          socket.send('{"type":"ping"}');
+        }, 30_000);
+      };
       socket.onclose = () => {
-        cleanup()
-        onClosed()
-      }
+        cleanup();
+        onClosed();
+      };
       socket.onmessage = (messageEvent) => {
-        const event = JSON.parse(messageEvent.data)
-        eventsManager.triggerCallbacks(event)
-      }
+        const event = JSON.parse(messageEvent.data);
+        eventsManager.triggerCallbacks(event);
+      };
       return () => {
         if (socket) {
-          socket.close()
-          cleanup()
+          socket.close();
+          cleanup();
         }
-      }
+      };
     },
     { retry, retryAfter, retryMaxAttempt, retryAllocatedMs },
-  )
+  );
   const eventsManager = createEventsManager({
     effect: () => {
       if (useEventsToManageConnection) {
-        connectionManager.connect()
+        connectionManager.connect();
         return () => {
-          connectionManager.disconnect()
-        }
+          connectionManager.disconnect();
+        };
       }
-      return null
+      return null;
     },
-  })
+  });
 
   return {
     readyState: connectionManager.readyState,
     connect: connectionManager.connect,
     disconnect: connectionManager.disconnect,
     listenEvents: (namedCallbacks) => {
-      return eventsManager.addCallbacks(namedCallbacks)
+      return eventsManager.addCallbacks(namedCallbacks);
     },
     destroy: () => {
-      connectionManager.destroy()
-      eventsManager.destroy()
+      connectionManager.destroy();
+      eventsManager.destroy();
     },
-  }
-}
+  };
+};

package/src/plugins/server_events/jsenv_plugin_server_events_client_injection.js

@@ -8,12 +8,12 @@ import {
   stringifyHtmlAst,
   injectHtmlNodeAsEarlyAsPossible,
   createHtmlNode,
-} from "@jsenv/ast"
+} from "@jsenv/ast";
 
 const serverEventsClientFileUrl = new URL(
   "./client/server_events_client.js",
   import.meta.url,
-).href
+).href;
 
 export const jsenvPluginServerEventsClientInjection = () => {
   return {
@@ -21,7 +21,7 @@ export const jsenvPluginServerEventsClientInjection = () => {
     appliesDuring: "*",
     transformUrlContent: {
       html: (htmlUrlInfo, context) => {
-        const htmlAst = parseHtmlString(htmlUrlInfo.content)
+        const htmlAst = parseHtmlString(htmlUrlInfo.content);
         const [serverEventsClientFileReference] = context.referenceUtils.inject(
           {
             type: "script",
@@ -29,7 +29,7 @@ export const jsenvPluginServerEventsClientInjection = () => {
             expectedType: "js_module",
             specifier: serverEventsClientFileUrl,
           },
-        )
+        );
         injectHtmlNodeAsEarlyAsPossible(
           htmlAst,
           createHtmlNode({
@@ -38,12 +38,12 @@ export const jsenvPluginServerEventsClientInjection = () => {
             src: serverEventsClientFileReference.generatedSpecifier,
           }),
           "jsenv:server_events",
-        )
-        const htmlModified = stringifyHtmlAst(htmlAst)
+        );
+        const htmlModified = stringifyHtmlAst(htmlAst);
         return {
           content: htmlModified,
-        }
+        };
       },
     },
-  }
-}
+  };
+};