@jsenv/test 1.1.2 → 1.1.4

package/src/runtime_browsers/webkit.js

@@ -1,15 +1,15 @@
-import { createRuntimeUsingPlaywright } from "./using_playwright.js"
+import { createRuntimeUsingPlaywright } from "./using_playwright.js";
 
 export const webkit = (params) => {
-  return createWekbitRuntime(params)
-}
+  return createWekbitRuntime(params);
+};
 
 export const webkitIsolatedTab = (params) => {
   return createWekbitRuntime({
     ...params,
     isolatedTab: true,
-  })
-}
+  });
+};
 
 const createWekbitRuntime = (params) => {
   return createRuntimeUsingPlaywright({
@@ -23,17 +23,17 @@ const createWekbitRuntime = (params) => {
       // I suppose it's due to some race condition to decide if the promise is catched or not
       // for now we'll ignore unhandled rejection on wekbkit
       if (error.name === "Unhandled Promise Rejection") {
-        return true
+        return true;
       }
-      return false
+      return false;
     },
     transformErrorHook: (error) => {
       // Force error stack to contain the error message
       // because it's not the case on webkit
       error.stack = `${error.message}
-    at ${error.stack}`
-      return error
+    at ${error.stack}`;
+      return error;
     },
     ...params,
-  })
-}
+  });
+};

package/src/runtime_node/child_exec_options.js

@@ -1,7 +1,7 @@
-import { findFreePort } from "@jsenv/server"
+import { findFreePort } from "@jsenv/server";
 
-import { createDetailedMessage } from "@jsenv/log"
-import { ExecOptions } from "./exec_options.js"
+import { createDetailedMessage } from "@jsenv/log";
+import { ExecOptions } from "./exec_options.js";
 
 export const createChildExecOptions = async ({
   signal = new AbortController().signal,
@@ -22,18 +22,18 @@ export const createChildExecOptions = async ({
         ["debug mode"]: debugMode,
         ["allowed debug mode"]: AVAILABLE_DEBUG_MODE,
       }),
-    )
+    );
   }
-  const childExecOptions = ExecOptions.fromExecArgv(processExecArgv)
+  const childExecOptions = ExecOptions.fromExecArgv(processExecArgv);
   await mutateDebuggingOptions(childExecOptions, {
     signal,
     processDebugPort,
     debugMode,
     debugPort,
     debugModeInheritBreak,
-  })
-  return childExecOptions
-}
+  });
+  return childExecOptions;
+};
 
 const AVAILABLE_DEBUG_MODE = [
   "none",
@@ -42,7 +42,7 @@ const AVAILABLE_DEBUG_MODE = [
   "inspect-brk",
   "debug",
   "debug-brk",
-]
+];
 
 const mutateDebuggingOptions = async (
   childExecOptions,
@@ -55,24 +55,24 @@ const mutateDebuggingOptions = async (
     debugModeInheritBreak,
   },
 ) => {
-  const parentDebugInfo = getDebugInfo(childExecOptions)
-  const parentDebugModeOptionName = parentDebugInfo.debugModeOptionName
-  const parentDebugPortOptionName = parentDebugInfo.debugPortOptionName
+  const parentDebugInfo = getDebugInfo(childExecOptions);
+  const parentDebugModeOptionName = parentDebugInfo.debugModeOptionName;
+  const parentDebugPortOptionName = parentDebugInfo.debugPortOptionName;
   const childDebugModeOptionName = getChildDebugModeOptionName({
     parentDebugModeOptionName,
     debugMode,
     debugModeInheritBreak,
-  })
+  });
 
   if (!childDebugModeOptionName) {
     // remove debug mode and debug port fron child options
     if (parentDebugModeOptionName) {
-      delete childExecOptions[parentDebugModeOptionName]
+      delete childExecOptions[parentDebugModeOptionName];
     }
     if (parentDebugPortOptionName) {
-      delete childExecOptions[parentDebugPortOptionName]
+      delete childExecOptions[parentDebugPortOptionName];
     }
-    return
+    return;
   }
 
   // replace child debug mode
@@ -80,24 +80,24 @@ const mutateDebuggingOptions = async (
     parentDebugModeOptionName &&
     parentDebugModeOptionName !== childDebugModeOptionName
   ) {
-    delete childExecOptions[parentDebugModeOptionName]
+    delete childExecOptions[parentDebugModeOptionName];
   }
-  childExecOptions[childDebugModeOptionName] = ""
+  childExecOptions[childDebugModeOptionName] = "";
 
   // this is required because vscode does not
   // support assigning a child spawned without a specific port
   const childDebugPortOptionValue =
     debugPort === 0
       ? await findFreePort(processDebugPort + 37, { signal })
-      : debugPort
+      : debugPort;
   // replace child debug port
   if (parentDebugPortOptionName) {
-    delete childExecOptions[parentDebugPortOptionName]
+    delete childExecOptions[parentDebugPortOptionName];
   }
   childExecOptions[childDebugModeOptionName] = portToArgValue(
     childDebugPortOptionValue,
-  )
-}
+  );
+};
 
 const getChildDebugModeOptionName = ({
   parentDebugModeOptionName,
@@ -105,61 +105,61 @@ const getChildDebugModeOptionName = ({
   debugModeInheritBreak,
 }) => {
   if (debugMode === "none") {
-    return undefined
+    return undefined;
   }
   if (debugMode !== "inherit") {
-    return `--${debugMode}`
+    return `--${debugMode}`;
   }
   if (!parentDebugModeOptionName) {
-    return undefined
+    return undefined;
   }
   if (!debugModeInheritBreak && parentDebugModeOptionName === "--inspect-brk") {
-    return "--inspect"
+    return "--inspect";
   }
   if (!debugModeInheritBreak && parentDebugModeOptionName === "--debug-brk") {
-    return "--debug"
+    return "--debug";
   }
-  return parentDebugModeOptionName
-}
+  return parentDebugModeOptionName;
+};
 
 const portToArgValue = (port) => {
-  if (typeof port !== "number") return ""
-  if (port === 0) return ""
-  return port
-}
+  if (typeof port !== "number") return "";
+  if (port === 0) return "";
+  return port;
+};
 
 // https://nodejs.org/en/docs/guides/debugging-getting-started/
 const getDebugInfo = (processOptions) => {
-  const inspectOption = processOptions["--inspect"]
+  const inspectOption = processOptions["--inspect"];
   if (inspectOption !== undefined) {
     return {
       debugModeOptionName: "--inspect",
       debugPortOptionName: "--inspect-port",
-    }
+    };
   }
-  const inspectBreakOption = processOptions["--inspect-brk"]
+  const inspectBreakOption = processOptions["--inspect-brk"];
   if (inspectBreakOption !== undefined) {
     return {
       debugModeOptionName: "--inspect-brk",
       debugPortOptionName: "--inspect-port",
-    }
+    };
   }
-  const debugOption = processOptions["--debug"]
+  const debugOption = processOptions["--debug"];
   if (debugOption !== undefined) {
     return {
       debugModeOptionName: "--debug",
       debugPortOptionName: "--debug-port",
-    }
+    };
   }
-  const debugBreakOption = processOptions["--debug-brk"]
+  const debugBreakOption = processOptions["--debug-brk"];
   if (debugBreakOption !== undefined) {
     return {
       debugModeOptionName: "--debug-brk",
       debugPortOptionName: "--debug-port",
-    }
+    };
   }
-  return {}
-}
+  return {};
+};
 
 // export const processIsExecutedByVSCode = () => {
 //   return typeof process.env.VSCODE_PID === "string"

package/src/runtime_node/controllable_child_process.mjs

@@ -1,34 +1,34 @@
-import { uneval } from "@jsenv/uneval"
+import { uneval } from "@jsenv/uneval";
 
-import { executeUsingDynamicImport } from "./execute_using_dynamic_import.js"
+import { executeUsingDynamicImport } from "./execute_using_dynamic_import.js";
 
 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)
+    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 = {}
+    const namespace = require(filePath);
+    const namespaceResolved = {};
     await Promise.all(
       Object.keys(namespace).map(async (key) => {
-        const value = await namespace[key]
-        namespaceResolved[key] = value
+        const value = await namespace[key];
+        namespaceResolved[key] = value;
       }),
-    )
-    return namespaceResolved
+    );
+    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 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
+    delete error.toString;
   }
   sendToParent(
     ACTION_RESPONSE_EVENT_NAME,
@@ -41,8 +41,8 @@ const sendActionFailed = (error) => {
       },
       { ignoreSymbols: true },
     ),
-  )
-}
+  );
+};
 
 const sendActionCompleted = (value) => {
   sendToParent(
@@ -55,14 +55,14 @@ const sendActionCompleted = (value) => {
       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
+    return;
   }
   // this can keep process alive longer than expected
   // when source is a long string.
@@ -72,57 +72,57 @@ const sendToParent = (type, data) => {
     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)
+      removeListener(); // commenting this line keep this process alive
+      callback(message.data);
     }
-  }
+  };
   const removeListener = () => {
-    process.removeListener("message", listener)
-  }
-  process.on("message", listener)
-  return 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]
+    const action = ACTIONS_AVAILABLE[actionType];
     if (!action) {
-      sendActionFailed(new Error(`unknown action ${actionType}`))
-      return
+      sendActionFailed(new Error(`unknown action ${actionType}`));
+      return;
     }
 
-    let value
-    let failed = false
+    let value;
+    let failed = false;
     try {
-      value = await action(actionParams)
+      value = await action(actionParams);
     } catch (e) {
-      failed = true
-      value = e
+      failed = true;
+      value = e;
     }
 
     // setTimeout(() => {}, 100)
 
     if (failed) {
-      sendActionFailed(value)
+      sendActionFailed(value);
     } else {
-      sendActionCompleted(value)
+      sendActionCompleted(value);
     }
 
     // removeActionRequestListener()
     if (actionParams.exitAfterAction) {
-      removeActionRequestListener()
+      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
@@ -131,5 +131,5 @@ const removeActionRequestListener = onceParentMessage(
 // process.once("SIGINT", removeActionRequestListener)
 
 setTimeout(() => {
-  sendToParent("ready")
-})
+  sendToParent("ready");
+});

package/src/runtime_node/controllable_worker_thread.mjs

@@ -1,19 +1,19 @@
-import { parentPort } from "node:worker_threads"
-import { uneval } from "@jsenv/uneval"
+import { parentPort } from "node:worker_threads";
+import { uneval } from "@jsenv/uneval";
 
-import { executeUsingDynamicImport } from "./execute_using_dynamic_import.js"
+import { executeUsingDynamicImport } from "./execute_using_dynamic_import.js";
 
 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 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
+    delete error.toString;
   }
   sendToParent(
     ACTION_RESPONSE_EVENT_NAME,
@@ -26,8 +26,8 @@ const sendActionFailed = (error) => {
       },
       { ignoreSymbols: true },
     ),
-  )
-}
+  );
+};
 
 const sendActionCompleted = (value) => {
   sendToParent(
@@ -40,8 +40,8 @@ const sendActionCompleted = (value) => {
       status: ACTION_RESPONSE_STATUS_COMPLETED,
       value,
     }),
-  )
-}
+  );
+};
 
 const sendToParent = (type, data) => {
   // this can keep process alive longer than expected
@@ -52,52 +52,52 @@ const sendToParent = (type, data) => {
     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)
+      removeListener(); // commenting this line keep this worker alive
+      callback(message.data);
     }
-  }
+  };
   const removeListener = () => {
-    parentPort.removeListener("message", listener)
-  }
-  parentPort.on("message", listener)
-  return 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]
+    const action = ACTIONS_AVAILABLE[actionType];
     if (!action) {
-      sendActionFailed(new Error(`unknown action ${actionType}`))
-      return
+      sendActionFailed(new Error(`unknown action ${actionType}`));
+      return;
     }
 
-    let value
-    let failed = false
+    let value;
+    let failed = false;
     try {
-      value = await action(actionParams)
+      value = await action(actionParams);
     } catch (e) {
-      failed = true
-      value = e
+      failed = true;
+      value = e;
     }
 
     if (failed) {
-      sendActionFailed(value)
+      sendActionFailed(value);
     } else {
-      sendActionCompleted(value)
+      sendActionCompleted(value);
     }
     if (actionParams.exitAfterAction) {
-      removeActionRequestListener()
+      removeActionRequestListener();
     }
   },
-)
+);
 
 setTimeout(() => {
-  sendToParent("ready")
-})
+  sendToParent("ready");
+});

package/src/runtime_node/exec_options.js

@@ -1,57 +1,57 @@
 export const ExecOptions = {
   fromExecArgv: (execArgv) => {
-    const execOptions = {}
-    let i = 0
+    const execOptions = {};
+    let i = 0;
     while (i < execArgv.length) {
-      const execArg = execArgv[i]
-      const option = execOptionFromExecArg(execArg)
-      const existing = execOptions[option.name]
+      const execArg = execArgv[i];
+      const option = execOptionFromExecArg(execArg);
+      const existing = execOptions[option.name];
       if (existing) {
         execOptions[option.name] = Array.isArray(existing)
           ? [...existing, option.value]
-          : [existing, option.value]
+          : [existing, option.value];
       } else {
-        execOptions[option.name] = option.value
+        execOptions[option.name] = option.value;
       }
-      i++
+      i++;
     }
-    return execOptions
+    return execOptions;
   },
   toExecArgv: (execOptions) => {
-    const execArgv = []
+    const execArgv = [];
     Object.keys(execOptions).forEach((optionName) => {
-      const optionValue = execOptions[optionName]
+      const optionValue = execOptions[optionName];
       if (optionValue === "unset") {
-        return
+        return;
       }
       if (optionValue === "") {
-        execArgv.push(optionName)
-        return
+        execArgv.push(optionName);
+        return;
       }
       if (Array.isArray(optionValue)) {
         optionValue.forEach((subValue) => {
-          execArgv.push(`${optionName}=${subValue}`)
-        })
+          execArgv.push(`${optionName}=${subValue}`);
+        });
       } else {
-        execArgv.push(`${optionName}=${optionValue}`)
+        execArgv.push(`${optionName}=${optionValue}`);
       }
-    })
-    return execArgv
+    });
+    return execArgv;
   },
-}
+};
 
 const execOptionFromExecArg = (execArg) => {
-  const equalCharIndex = execArg.indexOf("=")
+  const equalCharIndex = execArg.indexOf("=");
   if (equalCharIndex === -1) {
     return {
       name: execArg,
       value: "",
-    }
+    };
   }
-  const name = execArg.slice(0, equalCharIndex)
-  const value = execArg.slice(equalCharIndex + 1)
+  const name = execArg.slice(0, equalCharIndex);
+  const value = execArg.slice(equalCharIndex + 1);
   return {
     name,
     value,
-  }
-}
+  };
+};