@jsenv/core 27.0.0-alpha.80 → 27.0.0-alpha.83

package/dist/babel_helpers/construct/construct.js

@@ -12,4 +12,4 @@ function reflectConstruct(Parent, args, Class) {
   return instance;
 }
 
-export default isNativeReflectConstruct() ? Reflect.construct : reflectConstruct;
+export default isNativeReflectConstruct() ? Reflect.construct.bind() : reflectConstruct;

package/dist/babel_helpers/extends/extends.js

@@ -13,4 +13,4 @@ function assign(target) {
   return target;
 }
 
-export default Object.assign || assign;
+export default Object.assign ? Object.assign.bind() : assign;

package/dist/babel_helpers/get/get.js

@@ -1,7 +1,7 @@
 import superPropBase from "../superPropBase/superPropBase.js";
 export default function _get() {
   if (typeof Reflect !== "undefined" && Reflect.get) {
-    _get = Reflect.get;
+    _get = Reflect.get.bind();
   } else {
     _get = function _get(target, property, receiver) {
       var base = superPropBase(target, property);

package/dist/babel_helpers/getPrototypeOf/getPrototypeOf.js

@@ -1,2 +1,2 @@
-export default Object.setPrototypeOf ? Object.getPrototypeOf : // eslint-disable-next-line no-proto
+export default Object.setPrototypeOf ? Object.getPrototypeOf.bind() : // eslint-disable-next-line no-proto
 o => o.__proto__ || Object.getPrototypeOf(o);

package/dist/babel_helpers/identity/identity.js

@@ -0,0 +1,3 @@
+export default function _identity(x) {
+  return x;
+}

package/dist/babel_helpers/setPrototypeOf/setPrototypeOf.js

@@ -1,5 +1,5 @@
-export default Object.setPrototypeOf || ((o, p) => {
+export default Object.setPrototypeOf ? Object.setPrototypeOf.bind() : (o, p) => {
   // eslint-disable-next-line no-proto
   o.__proto__ = p;
   return o;
-});
+};

package/dist/js/event_source_client.js

@@ -1,7 +1,211 @@
-import { createEventSourceConnection } from "@jsenv/utils/event_source/event_source.js";
 import { urlHotMetas } from "./import_meta_hot.js";
 import { htmlAttributeSrcSet } from "@jsenv/utils/html_ast/html_attribute_src_set.js";
 
+/* eslint-env browser */
+const createEventSourceConnection = (eventSourceUrl, events = {}, {
+  retryMaxAttempt = Infinity,
+  retryAllocatedMs = Infinity,
+  lastEventId
+} = {}) => {
+  const {
+    EventSource
+  } = window;
+
+  if (typeof EventSource !== "function") {
+    return () => {};
+  }
+
+  const eventSourceOrigin = new URL(eventSourceUrl).origin;
+  Object.keys(events).forEach(eventName => {
+    const eventCallback = events[eventName];
+
+    events[eventName] = e => {
+      if (e.origin === eventSourceOrigin) {
+        if (e.lastEventId) {
+          lastEventId = e.lastEventId;
+        }
+
+        eventCallback(e);
+      }
+    };
+  });
+  const status = {
+    value: "default",
+    goTo: value => {
+      if (value === status.value) {
+        return;
+      }
+
+      status.value = value;
+      status.onchange();
+    },
+    onchange: () => {}
+  };
+
+  let _disconnect = () => {};
+
+  const attemptConnection = url => {
+    const eventSource = new EventSource(url, {
+      withCredentials: true
+    });
+
+    _disconnect = () => {
+      if (status.value !== "connecting" && status.value !== "connected") {
+        console.warn(`disconnect() ignored because connection is ${status.value}`);
+        return;
+      }
+
+      eventSource.onerror = undefined;
+      eventSource.close();
+      Object.keys(events).forEach(eventName => {
+        eventSource.removeEventListener(eventName, events[eventName]);
+      });
+      status.goTo("disconnected");
+    };
+
+    let retryCount = 0;
+    let firstRetryMs = Date.now();
+
+    eventSource.onerror = errorEvent => {
+      if (errorEvent.target.readyState === EventSource.CONNECTING) {
+        if (retryCount > retryMaxAttempt) {
+          console.info(`could not connect after ${retryMaxAttempt} attempt`);
+
+          _disconnect();
+
+          return;
+        }
+
+        if (retryCount === 0) {
+          firstRetryMs = Date.now();
+        } else {
+          const allRetryDuration = Date.now() - firstRetryMs;
+
+          if (retryAllocatedMs && allRetryDuration > retryAllocatedMs) {
+            console.info(`could not connect in less than ${retryAllocatedMs} ms`);
+
+            _disconnect();
+
+            return;
+          }
+        }
+
+        retryCount++;
+        status.goTo("connecting");
+        return;
+      }
+
+      if (errorEvent.target.readyState === EventSource.CLOSED) {
+        _disconnect();
+
+        return;
+      }
+    };
+
+    eventSource.onopen = () => {
+      status.goTo("connected");
+    };
+
+    Object.keys(events).forEach(eventName => {
+      eventSource.addEventListener(eventName, events[eventName]);
+    });
+
+    if (!events.hasOwnProperty("welcome")) {
+      eventSource.addEventListener("welcome", e => {
+        if (e.origin === eventSourceOrigin && e.lastEventId) {
+          lastEventId = e.lastEventId;
+        }
+      });
+    }
+
+    status.goTo("connecting");
+  };
+
+  let connect = () => {
+    attemptConnection(eventSourceUrl);
+
+    connect = () => {
+      attemptConnection(lastEventId ? addLastEventIdIntoUrlSearchParams(eventSourceUrl, lastEventId) : eventSourceUrl);
+    };
+  };
+
+  const removePageUnloadListener = listenPageUnload(() => {
+    if (status.value === "connecting" || status.value === "connected") {
+      _disconnect();
+    }
+  });
+
+  const destroy = () => {
+    removePageUnloadListener();
+
+    _disconnect();
+  };
+
+  return {
+    status,
+    connect,
+    disconnect: () => _disconnect(),
+    destroy
+  };
+};
+
+const addLastEventIdIntoUrlSearchParams = (url, lastEventId) => {
+  if (url.indexOf("?") === -1) {
+    url += "?";
+  } else {
+    url += "&";
+  }
+
+  return `${url}last-event-id=${encodeURIComponent(lastEventId)}`;
+}; // const listenPageMightFreeze = (callback) => {
+//   const removePageHideListener = listenEvent(window, "pagehide", (pageHideEvent) => {
+//     if (pageHideEvent.persisted === true) {
+//       callback(pageHideEvent)
+//     }
+//   })
+//   return removePageHideListener
+// }
+// const listenPageFreeze = (callback) => {
+//   const removeFreezeListener = listenEvent(document, "freeze", (freezeEvent) => {
+//     callback(freezeEvent)
+//   })
+//   return removeFreezeListener
+// }
+// const listenPageIsRestored = (callback) => {
+//   const removeResumeListener = listenEvent(document, "resume", (resumeEvent) => {
+//     removePageshowListener()
+//     callback(resumeEvent)
+//   })
+//   const removePageshowListener = listenEvent(window, "pageshow", (pageshowEvent) => {
+//     if (pageshowEvent.persisted === true) {
+//       removePageshowListener()
+//       removeResumeListener()
+//       callback(pageshowEvent)
+//     }
+//   })
+//   return () => {
+//     removeResumeListener()
+//     removePageshowListener()
+//   }
+// }
+
+
+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 () => {
+    emitter.removeEventListener(event, callback);
+  };
+};
+
 const isAutoreloadEnabled = () => {
   const value = window.localStorage.getItem("autoreload");