@jsenv/core 27.0.0-alpha.8 → 27.0.0-alpha.82

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/js/event_source_client.js

@@ -0,0 +1,324 @@
+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";
+
+const isAutoreloadEnabled = () => {
+  const value = window.localStorage.getItem("autoreload");
+
+  if (value === "0") {
+    return false;
+  }
+
+  return true;
+};
+const setAutoreloadPreference = value => {
+  window.localStorage.setItem("autoreload", value ? "1" : "0");
+};
+
+const compareTwoUrlPaths = (url, otherUrl) => {
+  if (url === otherUrl) {
+    return true;
+  }
+
+  const urlObject = new URL(url);
+  const otherUrlObject = new URL(otherUrl);
+  return urlObject.origin === otherUrlObject.origin && urlObject.pathname === otherUrlObject.pathname;
+};
+const injectQuery = (url, query) => {
+  const urlObject = new URL(url);
+  const {
+    searchParams
+  } = urlObject;
+  Object.keys(query).forEach(key => {
+    searchParams.set(key, query[key]);
+  });
+  return String(urlObject);
+};
+
+const reloadHtmlPage = () => {
+  window.location.reload(true);
+}; // This function can consider everything as hot reloadable:
+// - no need to check [hot-accept]and [hot-decline] attributes for instance
+// This is because if something should full reload, we receive "full_reload"
+// from server and this function is not called
+
+const reloadDOMNodesUsingUrl = urlToReload => {
+  const mutations = [];
+
+  const shouldReloadUrl = urlCandidate => {
+    return compareTwoUrlPaths(urlCandidate, urlToReload);
+  };
+
+  const visitNodeAttributeAsUrl = (node, attributeName) => {
+    let attribute = node[attributeName];
+
+    if (!attribute) {
+      return;
+    }
+
+    if (SVGAnimatedString && attribute instanceof SVGAnimatedString) {
+      attribute = attribute.animVal;
+    }
+
+    if (!shouldReloadUrl(attribute)) {
+      return;
+    }
+
+    mutations.push(() => {
+      node[attributeName] = injectQuery(attribute, {
+        hmr: Date.now()
+      });
+    });
+  };
+
+  Array.from(document.querySelectorAll(`link[rel="stylesheet"]`)).forEach(link => {
+    visitNodeAttributeAsUrl(link, "href");
+  });
+  Array.from(document.querySelectorAll(`link[rel="icon"]`)).forEach(link => {
+    visitNodeAttributeAsUrl(link, "href");
+  });
+  Array.from(document.querySelector("script")).forEach(script => {
+    visitNodeAttributeAsUrl(script, "src");
+  }); // There is no real need to update a.href because the ressource will be fetched when clicked.
+  // But in a scenario where the ressource was already visited and is in browser cache, adding
+  // the dynamic query param ensure the cache is invalidated
+
+  Array.from(document.querySelectorAll("a")).forEach(a => {
+    visitNodeAttributeAsUrl(a, "href");
+  }); // About iframes:
+  // - By default iframe itself and everything inside trigger a parent page full-reload
+  // - Adding [hot-accept] on the iframe means parent page won't reload when iframe full/hot reload
+  //   In that case and if there is code in the iframe and parent doing post message communication:
+  //   you must put import.meta.hot.decline() for code involved in communication.
+  //   (both in parent and iframe)
+
+  Array.from(document.querySelectorAll("img")).forEach(img => {
+    visitNodeAttributeAsUrl(img, "src");
+    const srcset = img.srcset;
+
+    if (srcset) {
+      const srcCandidates = htmlAttributeSrcSet.parse(srcset);
+      srcCandidates.forEach(srcCandidate => {
+        const url = new URL(srcCandidate.specifier, `${window.location.href}`);
+
+        if (shouldReloadUrl(url)) {
+          srcCandidate.specifier = injectQuery(url, {
+            hmr: Date.now()
+          });
+        }
+      });
+      mutations.push(() => {
+        img.srcset = htmlAttributeSrcSet.stringify(srcCandidates);
+      });
+    }
+  });
+  Array.from(document.querySelectorAll("source")).forEach(source => {
+    visitNodeAttributeAsUrl(source, "src");
+  }); // svg image tag
+
+  Array.from(document.querySelectorAll("image")).forEach(image => {
+    visitNodeAttributeAsUrl(image, "href");
+  }); // svg use
+
+  Array.from(document.querySelectorAll("use")).forEach(use => {
+    visitNodeAttributeAsUrl(use, "href");
+  });
+  mutations.forEach(mutation => {
+    mutation();
+  });
+};
+const reloadJsImport = async url => {
+  const urlWithHmr = injectQuery(url, {
+    hmr: Date.now()
+  });
+  const namespace = await import(urlWithHmr);
+  return namespace;
+};
+
+const reloadMessages = [];
+const reloadMessagesSignal = {
+  onchange: () => {}
+};
+let pendingCallbacks = [];
+let running = false;
+
+const addToHotQueue = async callback => {
+  pendingCallbacks.push(callback);
+  dequeue();
+};
+
+const dequeue = async () => {
+  if (running) {
+    return;
+  }
+
+  const callbacks = pendingCallbacks.slice();
+  pendingCallbacks = [];
+  running = true;
+
+  try {
+    await callbacks.reduce(async (previous, callback) => {
+      await previous;
+      await callback();
+    }, Promise.resolve());
+  } finally {
+    running = false;
+
+    if (pendingCallbacks.length) {
+      dequeue();
+    }
+  }
+};
+
+const applyReloadMessageEffects = async () => {
+  const someEffectIsFullReload = reloadMessages.some(reloadMessage => reloadMessage.type === "full");
+
+  if (someEffectIsFullReload) {
+    reloadHtmlPage();
+    return;
+  }
+
+  const onApplied = reloadMessage => {
+    const index = reloadMessages.indexOf(reloadMessage);
+    reloadMessages.splice(index, 1);
+    reloadMessagesSignal.onchange();
+  };
+
+  const setReloadMessagePromise = (reloadMessage, promise) => {
+    reloadMessage.status = "pending";
+    promise.then(() => {
+      onApplied(reloadMessage);
+    }, e => {
+      // TODO: reuse error display from html supervisor
+      console.error(e);
+      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();
+    });
+  };
+
+  reloadMessages.forEach(reloadMessage => {
+    if (reloadMessage.type === "hot") {
+      const promise = addToHotQueue(() => {
+        return applyHotReload(reloadMessage);
+      });
+      setReloadMessagePromise(reloadMessage, promise);
+    } else {
+      setReloadMessagePromise(reloadMessage, Promise.resolve());
+    }
+  });
+  reloadMessagesSignal.onchange(); // reload status is "pending"
+};
+
+const applyHotReload = async ({
+  hotInstructions
+}) => {
+  await hotInstructions.reduce(async (previous, {
+    type,
+    boundary,
+    acceptedBy
+  }) => {
+    await previous;
+    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: ${boundary} (inside ${acceptedBy})`);
+    } else if (acceptedBy === boundary) {
+      console.groupCollapsed(`[jsenv] hot reloading: ${boundary}`);
+    } else {
+      console.groupCollapsed(`[jsenv] hot reloading: ${acceptedBy} inside ${boundary}`);
+    }
+
+    if (urlHotMeta && urlHotMeta.disposeCallback) {
+      console.log(`call dispose callback`);
+      await urlHotMeta.disposeCallback();
+    }
+
+    if (type === "prune") {
+      delete urlHotMetas[urlToFetch];
+      console.log(`cleanup pruned url`);
+      console.groupEnd();
+      return null;
+    }
+
+    if (type === "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.groupEnd();
+      return namespace;
+    }
+
+    if (type === "html") {
+      if (!compareTwoUrlPaths(urlToFetch, window.location.href)) {
+        // we are not in that HTML page
+        return null;
+      }
+
+      console.log(`reloading url`);
+      const urlToReload = new URL(acceptedBy, `${window.location.origin}/`).href;
+      reloadDOMNodesUsingUrl(urlToReload);
+      console.log(`url reloaded`);
+      console.groupEnd();
+      return null;
+    }
+
+    console.warn(`unknown update type: "${type}"`);
+    return null;
+  }, Promise.resolve());
+};
+
+const addReloadMessage = reloadMessage => {
+  reloadMessages.push(reloadMessage);
+
+  if (isAutoreloadEnabled()) {
+    applyReloadMessageEffects();
+  } else {
+    reloadMessagesSignal.onchange();
+  }
+};
+
+const eventsourceConnection = createEventSourceConnection(document.location.href, {
+  reload: ({
+    data
+  }) => {
+    const reloadMessage = JSON.parse(data);
+    addReloadMessage(reloadMessage);
+  }
+}, {
+  retryMaxAttempt: Infinity,
+  retryAllocatedMs: 20 * 1000
+});
+const {
+  status,
+  connect,
+  disconnect
+} = eventsourceConnection;
+connect();
+window.__jsenv_event_source_client__ = {
+  status,
+  connect,
+  disconnect,
+  isAutoreloadEnabled,
+  setAutoreloadPreference,
+  urlHotMetas,
+  reloadMessages,
+  reloadMessagesSignal,
+  applyReloadMessageEffects,
+  addReloadMessage
+}; // const findHotMetaUrl = (originalFileRelativeUrl) => {
+//   return Object.keys(urlHotMetas).find((compileUrl) => {
+//     return (
+//       parseCompiledUrl(compileUrl).fileRelativeUrl === originalFileRelativeUrl
+//     )
+//   })
+// }

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 };