@jsenv/core 27.0.0-alpha.64 → 27.0.0-alpha.67

package/dist/js/controllable_file.mjs

@@ -0,0 +1,227 @@
+import v8 from "node:v8";
+import { uneval } from "@jsenv/uneval";
+import { performance, PerformanceObserver } from "node:perf_hooks";
+
+const startObservingPerformances = () => {
+  const measureEntries = []; // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html
+
+  const perfObserver = new PerformanceObserver(( // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceobserverentrylist
+  list) => {
+    const perfMeasureEntries = list.getEntriesByType("measure");
+    measureEntries.push(...perfMeasureEntries);
+  });
+  perfObserver.observe({
+    entryTypes: ["measure"]
+  });
+  return async () => {
+    // wait for node to call the performance observer
+    await new Promise(resolve => {
+      setTimeout(resolve);
+    });
+    performance.clearMarks();
+    perfObserver.disconnect();
+    return { ...readNodePerformance(),
+      measures: measuresFromMeasureEntries(measureEntries)
+    };
+  };
+};
+
+const readNodePerformance = () => {
+  const nodePerformance = {
+    nodeTiming: asPlainObject(performance.nodeTiming),
+    timeOrigin: performance.timeOrigin,
+    eventLoopUtilization: performance.eventLoopUtilization()
+  };
+  return nodePerformance;
+}; // remove getters that cannot be stringified
+
+
+const asPlainObject = objectWithGetters => {
+  const objectWithoutGetters = {};
+  Object.keys(objectWithGetters).forEach(key => {
+    objectWithoutGetters[key] = objectWithGetters[key];
+  });
+  return objectWithoutGetters;
+};
+
+const measuresFromMeasureEntries = measureEntries => {
+  const measures = {}; // Sort to ensure measures order is predictable
+  // It seems to be already predictable on Node 16+ but
+  // it's not the case on Node 14.
+
+  measureEntries.sort((a, b) => {
+    return a.startTime - b.startTime;
+  });
+  measureEntries.forEach(( // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceentry
+  perfMeasureEntry) => {
+    measures[perfMeasureEntry.name] = perfMeasureEntry.duration;
+  });
+  return measures;
+};
+
+const ACTIONS_AVAILABLE = {
+  "execute-using-dynamic-import": async ({
+    fileUrl,
+    collectPerformance
+  }) => {
+    const getNamespace = async () => {
+      const namespace = await import(fileUrl);
+      const namespaceResolved = {};
+      await Promise.all([...Object.keys(namespace).map(async key => {
+        const value = await namespace[key];
+        namespaceResolved[key] = value;
+      })]);
+      return namespaceResolved;
+    };
+
+    if (collectPerformance) {
+      const getPerformance = startObservingPerformances();
+      const namespace = await getNamespace();
+      const performance = await getPerformance();
+      return {
+        namespace,
+        performance
+      };
+    }
+
+    const namespace = await getNamespace();
+    return {
+      namespace
+    };
+  },
+  "execute-using-require": async ({
+    fileUrl
+  }) => {
+    const {
+      createRequire
+    } = await import("module");
+    const {
+      fileURLToPath
+    } = await import("url");
+    const filePath = fileURLToPath(fileUrl);
+
+    const require = createRequire(fileUrl); // eslint-disable-next-line import/no-dynamic-require
+
+
+    const namespace = require(filePath);
+
+    const namespaceResolved = {};
+    await Promise.all([...Object.keys(namespace).map(async key => {
+      const value = await namespace[key];
+      namespaceResolved[key] = value;
+    })]);
+    return namespaceResolved;
+  }
+};
+const ACTION_REQUEST_EVENT_NAME = "action";
+const ACTION_RESPONSE_EVENT_NAME = "action-result";
+const ACTION_RESPONSE_STATUS_FAILED = "action-failed";
+const ACTION_RESPONSE_STATUS_COMPLETED = "action-completed";
+
+const sendActionFailed = error => {
+  if (error.hasOwnProperty("toString")) {
+    delete error.toString;
+  }
+
+  sendToParent(ACTION_RESPONSE_EVENT_NAME, // process.send algorithm does not send non enumerable values
+  // so use @jsenv/uneval
+  uneval({
+    status: ACTION_RESPONSE_STATUS_FAILED,
+    value: error
+  }, {
+    ignoreSymbols: true
+  }));
+};
+
+const sendActionCompleted = value => {
+  sendToParent(ACTION_RESPONSE_EVENT_NAME, // here we use JSON.stringify because we should not
+  // have non enumerable value (unlike there is on Error objects)
+  // otherwise uneval is quite slow to turn a giant object
+  // into a string (and value can be giant when using coverage)
+  JSON.stringify({
+    status: ACTION_RESPONSE_STATUS_COMPLETED,
+    value
+  }));
+};
+
+const sendToParent = (type, data) => {
+  // https://nodejs.org/api/process.html#process_process_connected
+  // not connected anymore, cannot communicate with parent
+  if (!process.connected) {
+    return;
+  } // this can keep process alive longer than expected
+  // when source is a long string.
+  // It means node process may stay alive longer than expected
+  // the time to send the data to the parent.
+
+
+  process.send({
+    type,
+    data
+  });
+};
+
+const onceProcessMessage = (type, callback) => {
+  const listener = event => {
+    if (event.type === type) {
+      // commenting line below keep this process alive
+      removeListener(); // eslint-disable-next-line no-eval
+
+      callback(eval(`(${event.data})`));
+    }
+  };
+
+  const removeListener = () => {
+    process.removeListener("message", listener);
+  };
+
+  process.on("message", listener);
+  return removeListener;
+};
+
+const removeActionRequestListener = onceProcessMessage(ACTION_REQUEST_EVENT_NAME, async ({
+  actionType,
+  actionParams
+}) => {
+  const action = ACTIONS_AVAILABLE[actionType];
+
+  if (!action) {
+    sendActionFailed(new Error(`unknown action ${actionType}`));
+    return;
+  }
+
+  let value;
+  let failed = false;
+
+  try {
+    value = await action(actionParams);
+  } catch (e) {
+    failed = true;
+    value = e;
+  }
+
+  if (process.env.NODE_V8_COVERAGE) {
+    v8.takeCoverage(); // if (actionParams.stopCoverageAfterExecution) {
+    //   v8.stopCoverage()
+    // }
+  } // setTimeout(() => {}, 100)
+
+
+  if (failed) {
+    sendActionFailed(value);
+  } else {
+    sendActionCompleted(value);
+  } // removeActionRequestListener()
+
+
+  if (actionParams.exitAfterAction) {
+    removeActionRequestListener(); // for some reason this fixes v8 coverage directory sometimes empty on Ubuntu
+    // process.exit()
+  }
+}); // remove listener to process.on('message')
+// which is sufficient to let child process die
+// assuming nothing else keeps it alive
+// process.once("SIGTERM", removeActionRequestListener)
+// process.once("SIGINT", removeActionRequestListener)
+
+setTimeout(() => sendToParent("ready"));

package/dist/{event_source_client.js → js/event_source_client.js}

@@ -1,209 +1,6 @@
+import { createEventSourceConnection } from "@jsenv/utils/event_source/event_source.js";
 import { urlHotMetas } from "./import_meta_hot.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 ".concat(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 ".concat(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 ".concat(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 "".concat(url, "last-event-id=").concat(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);
-  };
-};
+import { htmlAttributeSrcSet } from "@jsenv/utils/html_ast/html_attribute_src_set.js";
 
 const isAutoreloadEnabled = () => {
   const value = window.localStorage.getItem("autoreload");
@@ -238,27 +35,6 @@ const injectQuery = (url, query) => {
   return String(urlObject);
 };
 
-const htmlAttributeSrcSet = {
-  parse: srcset => {
-    const srcCandidates = [];
-    srcset.split(",").forEach(set => {
-      const [specifier, descriptor] = set.trim().split(" ");
-      srcCandidates.push({
-        specifier,
-        descriptor
-      });
-    });
-    return srcCandidates;
-  },
-  stringify: srcCandidates => {
-    const srcset = srcCandidates.map(({
-      specifier,
-      descriptor
-    }) => "".concat(specifier, " ").concat(descriptor)).join(", ");
-    return srcset;
-  }
-};
-
 const reloadHtmlPage = () => {
   window.location.reload(true);
 }; // This function can consider everything as hot reloadable:
@@ -295,10 +71,10 @@ const reloadDOMNodesUsingUrl = urlToReload => {
     });
   };
 
-  Array.from(document.querySelectorAll("link[rel=\"stylesheet\"]")).forEach(link => {
+  Array.from(document.querySelectorAll(`link[rel="stylesheet"]`)).forEach(link => {
     visitNodeAttributeAsUrl(link, "href");
   });
-  Array.from(document.querySelectorAll("link[rel=\"icon\"]")).forEach(link => {
+  Array.from(document.querySelectorAll(`link[rel="icon"]`)).forEach(link => {
     visitNodeAttributeAsUrl(link, "href");
   });
   Array.from(document.querySelector("script")).forEach(script => {
@@ -323,7 +99,7 @@ const reloadDOMNodesUsingUrl = urlToReload => {
     if (srcset) {
       const srcCandidates = htmlAttributeSrcSet.parse(srcset);
       srcCandidates.forEach(srcCandidate => {
-        const url = new URL(srcCandidate.specifier, "".concat(window.location.href));
+        const url = new URL(srcCandidate.specifier, `${window.location.href}`);
 
         if (shouldReloadUrl(url)) {
           srcCandidate.specifier = injectQuery(url, {
@@ -415,7 +191,8 @@ const applyReloadMessageEffects = async () => {
     }, e => {
       // TODO: reuse error display from html supervisor
       console.error(e);
-      console.error("[hmr] Failed to reload after ".concat(reloadMessage.reason, ".\nThis could be due to syntax errors or importing non-existent modules (see errors above)"));
+      console.error(`[hmr] Failed to reload after ${reloadMessage.reason}.
+This could be due to syntax errors or importing non-existent modules (see errors above)`);
       reloadMessage.status = "failed";
       reloadMessagesSignal.onchange();
     });
@@ -443,40 +220,40 @@ const applyHotReload = async ({
     acceptedBy
   }) => {
     await previous;
-    const urlToFetch = new URL(boundary, "".concat(window.location.origin, "/")).href;
+    const urlToFetch = new URL(boundary, `${window.location.origin}/`).href;
     const urlHotMeta = urlHotMetas[urlToFetch]; // TODO: we should return when there is no url hot meta because
     // it means code was not executed (code splitting with dynamic import)
     // if (!urlHotMeta) {return }
 
     if (type === "prune") {
-      console.groupCollapsed("[jsenv] prune: ".concat(boundary, " (inside ").concat(acceptedBy, ")"));
+      console.groupCollapsed(`[jsenv] prune: ${boundary} (inside ${acceptedBy})`);
     } else if (acceptedBy === boundary) {
-      console.groupCollapsed("[jsenv] hot reloading: ".concat(boundary));
+      console.groupCollapsed(`[jsenv] hot reloading: ${boundary}`);
     } else {
-      console.groupCollapsed("[jsenv] hot reloading: ".concat(acceptedBy, " inside ").concat(boundary));
+      console.groupCollapsed(`[jsenv] hot reloading: ${acceptedBy} inside ${boundary}`);
     }
 
     if (urlHotMeta && urlHotMeta.disposeCallback) {
-      console.log("call dispose callback");
+      console.log(`call dispose callback`);
       await urlHotMeta.disposeCallback();
     }
 
     if (type === "prune") {
       delete urlHotMetas[urlToFetch];
-      console.log("cleanup pruned url");
+      console.log(`cleanup pruned url`);
       console.groupEnd();
       return null;
     }
 
     if (type === "js_module") {
-      console.log("importing js module");
+      console.log(`importing js module`);
       const namespace = await reloadJsImport(urlToFetch);
 
       if (urlHotMeta && urlHotMeta.acceptCallback) {
         await urlHotMeta.acceptCallback(namespace);
       }
 
-      console.log("js module import done");
+      console.log(`js module import done`);
       console.groupEnd();
       return namespace;
     }
@@ -487,15 +264,15 @@ const applyHotReload = async ({
         return null;
       }
 
-      console.log("reloading url");
-      const urlToReload = new URL(acceptedBy, "".concat(window.location.origin, "/")).href;
+      console.log(`reloading url`);
+      const urlToReload = new URL(acceptedBy, `${window.location.origin}/`).href;
       reloadDOMNodesUsingUrl(urlToReload);
-      console.log("url reloaded");
+      console.log(`url reloaded`);
       console.groupEnd();
       return null;
     }
 
-    console.warn("unknown update type: \"".concat(type, "\""));
+    console.warn(`unknown update type: "${type}"`);
     return null;
   }, Promise.resolve());
 };
@@ -545,5 +322,3 @@ window.__jsenv_event_source_client__ = {
 //     )
 //   })
 // }
-
-//# sourceMappingURL=event_source_client.js.map

package/dist/js/global_this.js

@@ -0,0 +1,32 @@
+// https://mathiasbynens.be/notes/globalthis
+
+/* eslint-disable no-redeclare */
+
+/* global globalThis */
+let globalObject;
+
+if (typeof globalThis === "object") {
+  globalObject = globalThis;
+} else {
+  if (undefined) {
+    globalObject = undefined;
+  } else {
+    // eslint-disable-next-line no-extend-native
+    Object.defineProperty(Object.prototype, "__global__", {
+      get() {
+        return this;
+      },
+
+      configurable: true
+    }); // eslint-disable-next-line no-undef
+
+    globalObject = __global__;
+    delete Object.prototype.__global__;
+  }
+
+  globalObject.globalThis = globalObject;
+}
+
+var globalObject$1 = globalObject;
+
+export { globalObject$1 as default };