@jsenv/core 27.1.0 → 27.2.2

package/dist/controllable_child_process.mjs

@@ -0,0 +1,139 @@
+import { u as uneval } from "./js/uneval.js";
+import { e as executeUsingDynamicImport } from "./js/execute_using_dynamic_import.js";
+import "node:inspector";
+import "node:perf_hooks";
+
+const ACTIONS_AVAILABLE = {
+  "execute-using-dynamic-import": executeUsingDynamicImport,
+  "execute-using-require": async ({
+    fileUrl
+  }) => {
+    const {
+      createRequire
+    } = await import("node:module");
+    const {
+      fileURLToPath
+    } = await import("node: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({
+    jsenv: true,
+    type,
+    data
+  });
+};
+
+const onceParentMessage = (type, callback) => {
+  const listener = message => {
+    if (message && message.jsenv && message.type === type) {
+      removeListener(); // commenting this line keep this process alive
+
+      callback(message.data);
+    }
+  };
+
+  const removeListener = () => {
+    process.removeListener("message", listener);
+  };
+
+  process.on("message", listener);
+  return removeListener;
+};
+
+const removeActionRequestListener = onceParentMessage(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;
+  } // 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/controllable_worker_thread.mjs

@@ -0,0 +1,103 @@
+import { parentPort } from "node:worker_threads";
+import { u as uneval } from "./js/uneval.js";
+import { e as executeUsingDynamicImport } from "./js/execute_using_dynamic_import.js";
+import "node:inspector";
+import "node:perf_hooks";
+
+const ACTIONS_AVAILABLE = {
+  "execute-using-dynamic-import": executeUsingDynamicImport
+};
+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) => {
+  // 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.
+  parentPort.postMessage({
+    jsenv: true,
+    type,
+    data
+  });
+};
+
+const onceParentMessage = (type, callback) => {
+  const listener = message => {
+    if (message && message.jsenv && message.type === type) {
+      removeListener(); // commenting this line keep this worker alive
+
+      callback(message.data);
+    }
+  };
+
+  const removeListener = () => {
+    parentPort.removeListener("message", listener);
+  };
+
+  parentPort.on("message", listener);
+  return removeListener;
+};
+
+const removeActionRequestListener = onceParentMessage(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 (failed) {
+    sendActionFailed(value);
+  } else {
+    sendActionCompleted(value);
+  }
+
+  if (actionParams.exitAfterAction) {
+    removeActionRequestListener();
+  }
+});
+setTimeout(() => {
+  sendToParent("ready");
+});

package/dist/js/execute_using_dynamic_import.js

@@ -0,0 +1,169 @@
+import { Session } from "node:inspector";
+import { performance, PerformanceObserver } from "node:perf_hooks";
+
+/*
+ * Calling Profiler.startPreciseCoverage DO NOT propagate to
+ * subprocesses (new Worker or child_process.fork())
+ * So the best solution remains NODE_V8_COVERAGE
+ * This profiler strategy remains useful when:
+ * - As fallback when NODE_V8_COVERAGE is not configured
+ * - If explicitely enabled with coverageMethodForNodeJs: 'Profiler'
+ *   - Used by jsenv during automated tests about coverage
+ *   - Anyone prefering this approach over NODE_V8_COVERAGE and assuming
+ *     it will not fork subprocess or don't care if coverage is missed for this code
+ * - https://v8.dev/blog/javascript-code-coverage#for-embedders
+ * - https://github.com/nodejs/node/issues/28283
+ * - https://vanilla.aslushnikov.com/?Profiler.startPreciseCoverage
+ */
+const startJsCoverage = async ({
+  callCount = true,
+  detailed = true
+} = {}) => {
+  const session = new Session();
+  session.connect();
+
+  const postSession = (action, options) => {
+    const promise = new Promise((resolve, reject) => {
+      session.post(action, options, (error, data) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(data);
+        }
+      });
+    });
+    return promise;
+  };
+
+  await postSession("Profiler.enable");
+  await postSession("Profiler.startPreciseCoverage", {
+    callCount,
+    detailed
+  });
+
+  const takeJsCoverage = async () => {
+    const coverage = await postSession("Profiler.takePreciseCoverage");
+    return coverage;
+  };
+
+  const stopJsCoverage = async () => {
+    const coverage = await takeJsCoverage();
+    await postSession("Profiler.stopPreciseCoverage");
+    await postSession("Profiler.disable");
+    return coverage;
+  };
+
+  return {
+    takeJsCoverage,
+    stopJsCoverage
+  };
+};
+
+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 executeUsingDynamicImport = async ({
+  rootDirectoryUrl,
+  fileUrl,
+  collectPerformance,
+  coverageEnabled,
+  coverageConfig,
+  coverageMethodForNodeJs
+}) => {
+  let result = {};
+  const afterImportCallbacks = [];
+
+  if (coverageEnabled && coverageMethodForNodeJs === "Profiler") {
+    const {
+      filterV8Coverage
+    } = await import("./v8_coverage.js").then(function (n) { return n.v; });
+    const {
+      stopJsCoverage
+    } = await startJsCoverage();
+    afterImportCallbacks.push(async () => {
+      const coverage = await stopJsCoverage();
+      const coverageLight = await filterV8Coverage(coverage, {
+        rootDirectoryUrl,
+        coverageConfig
+      });
+      result.coverage = coverageLight;
+    });
+  }
+
+  if (collectPerformance) {
+    const getPerformance = startObservingPerformances();
+    afterImportCallbacks.push(async () => {
+      const performance = await getPerformance();
+      result.performance = performance;
+    });
+  }
+
+  const namespace = await import(fileUrl);
+  const namespaceResolved = {};
+  await Promise.all(Object.keys(namespace).map(async key => {
+    const value = await namespace[key];
+    namespaceResolved[key] = value;
+  }));
+  result.namespace = namespaceResolved;
+  await afterImportCallbacks.reduce(async (previous, afterImportCallback) => {
+    await previous;
+    await afterImportCallback();
+  }, Promise.resolve());
+  return result;
+};
+
+export { executeUsingDynamicImport as e };