@jsenv/core 35.0.3 → 35.0.4

package/src/dev/start_dev_server.js

@@ -1,18 +1,18 @@
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
-import { createLogger, createTaskLog } from "@jsenv/log"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
+import { Abort, raceProcessTeardownEvents } from "@jsenv/abort";
+import { createLogger, createTaskLog } from "@jsenv/log";
 import {
   jsenvAccessControlAllowedHeaders,
   startServer,
   jsenvServiceCORS,
   jsenvServiceErrorHandler,
-} from "@jsenv/server"
-import { convertFileSystemErrorToResponseProperties } from "@jsenv/server/src/internal/convertFileSystemErrorToResponseProperties.js"
+} from "@jsenv/server";
+import { convertFileSystemErrorToResponseProperties } from "@jsenv/server/src/internal/convertFileSystemErrorToResponseProperties.js";
 
-import { lookupPackageDirectory } from "../helpers/lookup_package_directory.js"
-import { createServerEventsDispatcher } from "../plugins/server_events/server_events_dispatcher.js"
-import { defaultRuntimeCompat } from "../build/build.js"
-import { createFileService } from "./file_service.js"
+import { lookupPackageDirectory } from "../helpers/lookup_package_directory.js";
+import { createServerEventsDispatcher } from "../plugins/server_events/server_events_dispatcher.js";
+import { defaultRuntimeCompat } from "../build/build.js";
+import { createFileService } from "./file_service.js";
 
 /**
  * Start a server for source files:
@@ -68,34 +68,34 @@ export const startDevServer = async ({
 }) => {
   // params type checking
   {
-    const unexpectedParamNames = Object.keys(rest)
+    const unexpectedParamNames = Object.keys(rest);
     if (unexpectedParamNames.length > 0) {
       throw new TypeError(
         `${unexpectedParamNames.join(",")}: there is no such param`,
-      )
+      );
     }
     sourceDirectoryUrl = assertAndNormalizeDirectoryUrl(
       sourceDirectoryUrl,
       "sourceDirectoryUrl",
-    )
+    );
     if (outDirectoryUrl === undefined) {
       if (!process.env.CI) {
-        const packageDirectoryUrl = lookupPackageDirectory(sourceDirectoryUrl)
+        const packageDirectoryUrl = lookupPackageDirectory(sourceDirectoryUrl);
         if (packageDirectoryUrl) {
-          outDirectoryUrl = `${packageDirectoryUrl}.jsenv/`
+          outDirectoryUrl = `${packageDirectoryUrl}.jsenv/`;
         }
       }
     } else if (outDirectoryUrl !== null && outDirectoryUrl !== false) {
       outDirectoryUrl = assertAndNormalizeDirectoryUrl(
         outDirectoryUrl,
         "outDirectoryUrl",
-      )
+      );
     }
   }
 
-  const logger = createLogger({ logLevel })
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
+  const logger = createLogger({ logLevel });
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
   if (handleSIGINT) {
     operation.addAbortSource((abort) => {
       return raceProcessTeardownEvents(
@@ -103,19 +103,19 @@ export const startDevServer = async ({
           SIGINT: true,
         },
         abort,
-      )
-    })
+      );
+    });
   }
   const startDevServerTask = createTaskLog("start dev server", {
     disabled: !logger.levels.info,
-  })
+  });
 
-  const serverStopCallbacks = []
-  const serverEventsDispatcher = createServerEventsDispatcher()
+  const serverStopCallbacks = [];
+  const serverEventsDispatcher = createServerEventsDispatcher();
   serverStopCallbacks.push(() => {
-    serverEventsDispatcher.destroy()
-  })
-  const contextCache = new Map()
+    serverEventsDispatcher.destroy();
+  });
+  const contextCache = new Map();
   const server = await startServer({
     signal,
     stopOnExit: false,
@@ -137,12 +137,12 @@ export const startDevServer = async ({
       {
         handleRequest: (request) => {
           if (request.headers["x-server-inspect"]) {
-            return { status: 200 }
+            return { status: 200 };
           }
           if (request.pathname === "/__params__.json") {
             const json = JSON.stringify({
               sourceDirectoryUrl,
-            })
+            });
             return {
               status: 200,
               headers: {
@@ -150,12 +150,12 @@ export const startDevServer = async ({
                 "content-length": Buffer.byteLength(json),
               },
               body: json,
-            }
+            };
           }
-          return null
+          return null;
         },
         injectResponseHeaders: () => {
-          return { server: "jsenv_dev_server/1" }
+          return { server: "jsenv_dev_server/1" };
         },
       },
       jsenvServiceCORS({
@@ -202,7 +202,7 @@ export const startDevServer = async ({
         }),
         handleWebsocket: (websocket, { request }) => {
           if (request.headers["sec-websocket-protocol"] === "jsenv") {
-            serverEventsDispatcher.addWebsocket(websocket, request)
+            serverEventsDispatcher.addWebsocket(websocket, request);
           }
         },
       },
@@ -211,7 +211,7 @@ export const startDevServer = async ({
         handleError: (error) => {
           const getResponseForError = () => {
             if (error && error.asResponse) {
-              return error.asResponse()
+              return error.asResponse();
             }
             if (
               error &&
@@ -219,20 +219,20 @@ export const startDevServer = async ({
             ) {
               return {
                 status: 403,
-              }
+              };
             }
-            return convertFileSystemErrorToResponseProperties(error)
-          }
-          const response = getResponseForError()
+            return convertFileSystemErrorToResponseProperties(error);
+          };
+          const response = getResponseForError();
           if (!response) {
-            return null
+            return null;
           }
           const body = JSON.stringify({
             status: response.status,
             statusText: response.statusText,
             headers: response.headers,
             body: response.body,
-          })
+          });
           return {
             status: 200,
             headers: {
@@ -240,7 +240,7 @@ export const startDevServer = async ({
               "content-length": Buffer.byteLength(body),
             },
             body,
-          }
+          };
         },
       },
       // default error handling
@@ -248,29 +248,29 @@ export const startDevServer = async ({
         sendErrorDetails: true,
       }),
     ],
-  })
+  });
   server.stoppedPromise.then((reason) => {
-    onStop()
+    onStop();
     serverStopCallbacks.forEach((serverStopCallback) => {
-      serverStopCallback(reason)
-    })
-    serverStopCallbacks.length = 0
-  })
-  startDevServerTask.done()
+      serverStopCallback(reason);
+    });
+    serverStopCallbacks.length = 0;
+  });
+  startDevServerTask.done();
   if (hostname) {
-    delete server.origins.localip
-    delete server.origins.externalip
+    delete server.origins.localip;
+    delete server.origins.externalip;
   }
-  logger.info(``)
+  logger.info(``);
   Object.keys(server.origins).forEach((key) => {
-    logger.info(`- ${server.origins[key]}`)
-  })
-  logger.info(``)
+    logger.info(`- ${server.origins[key]}`);
+  });
+  logger.info(``);
   return {
     origin: server.origin,
     stop: () => {
-      server.stop()
+      server.stop();
     },
     contextCache,
-  }
-}
+  };
+};

package/src/dev/user_agent.js

@@ -1,6 +1,6 @@
-import { memoizeByFirstArgument } from "@jsenv/utils/src/memoize/memoize_by_first_argument.js"
+import { memoizeByFirstArgument } from "@jsenv/utils/src/memoize/memoize_by_first_argument.js";
 
-import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js";
 
 export const parseUserAgentHeader = memoizeByFirstArgument((userAgent) => {
   if (userAgent.includes("node-fetch/")) {
@@ -9,14 +9,14 @@ export const parseUserAgentHeader = memoizeByFirstArgument((userAgent) => {
     return {
       runtimeName: "node",
       runtimeVersion: process.version.slice(1),
-    }
+    };
   }
-  const UA = requireFromJsenv("@financial-times/polyfill-useragent-normaliser")
-  const { ua } = new UA(userAgent)
-  const { family, major, minor, patch } = ua
+  const UA = requireFromJsenv("@financial-times/polyfill-useragent-normaliser");
+  const { ua } = new UA(userAgent);
+  const { family, major, minor, patch } = ua;
   return {
     runtimeName: family.toLowerCase(),
     runtimeVersion:
       family === "Other" ? "unknown" : `${major}.${minor}${patch}`,
-  }
-})
+  };
+});

package/src/helpers/basic_fetch.js

@@ -2,15 +2,15 @@ export const basicFetch = async (
   url,
   { rejectUnauthorized = true, method = "GET", headers = {} } = {},
 ) => {
-  let requestModule
+  let requestModule;
   if (url.startsWith("http:")) {
-    requestModule = await import("node:http")
+    requestModule = await import("node:http");
   } else {
-    requestModule = await import("node:https")
+    requestModule = await import("node:https");
   }
-  const { request } = requestModule
+  const { request } = requestModule;
 
-  const urlObject = new URL(url)
+  const urlObject = new URL(url);
 
   return new Promise((resolve, reject) => {
     const req = request({
@@ -20,34 +20,34 @@ export const basicFetch = async (
       path: urlObject.pathname,
       method,
       headers,
-    })
+    });
     req.on("response", (response) => {
       resolve({
         status: response.statusCode,
         headers: response.headers,
         json: () => {
-          req.setTimeout(0)
-          req.destroy()
+          req.setTimeout(0);
+          req.destroy();
           return new Promise((resolve) => {
             if (response.headers["content-type"] !== "application/json") {
-              console.warn("not json")
+              console.warn("not json");
             }
-            let responseBody = ""
-            response.setEncoding("utf8")
+            let responseBody = "";
+            response.setEncoding("utf8");
             response.on("data", (chunk) => {
-              responseBody += chunk
-            })
+              responseBody += chunk;
+            });
             response.on("end", () => {
-              resolve(JSON.parse(responseBody))
-            })
+              resolve(JSON.parse(responseBody));
+            });
             response.on("error", (e) => {
-              reject(e)
-            })
-          })
+              reject(e);
+            });
+          });
         },
-      })
-    })
-    req.on("error", reject)
-    req.end()
-  })
-}
+      });
+    });
+    req.on("error", reject);
+    req.end();
+  });
+};

package/src/helpers/command/command.js

@@ -1,5 +1,5 @@
-import { exec } from "node:child_process"
-import { createDetailedMessage, createLogger, UNICODE } from "@jsenv/log"
+import { exec } from "node:child_process";
+import { createDetailedMessage, createLogger, UNICODE } from "@jsenv/log";
 
 export const executeCommand = (
   command,
@@ -13,10 +13,10 @@ export const executeCommand = (
     timeout,
   } = {},
 ) => {
-  const logger = createLogger({ logLevel })
+  const logger = createLogger({ logLevel });
 
   return new Promise((resolve, reject) => {
-    logger.debug(`${UNICODE.COMMAND} ${command}`)
+    logger.debug(`${UNICODE.COMMAND} ${command}`);
     const commandProcess = exec(command, {
       signal,
       cwd:
@@ -26,35 +26,35 @@ export const executeCommand = (
       env,
       timeout,
       silent: true,
-    })
+    });
     commandProcess.on("error", (error) => {
       if (error && error.code === "ETIMEDOUT") {
-        logger.error(`timeout after ${timeout} ms`)
-        reject(error)
+        logger.error(`timeout after ${timeout} ms`);
+        reject(error);
       } else {
-        reject(error)
+        reject(error);
       }
-    })
-    const stdoutDatas = []
+    });
+    const stdoutDatas = [];
     commandProcess.stdout.on("data", (data) => {
-      stdoutDatas.push(data)
-      logger.debug(data)
-      onStderr(data)
-    })
-    let stderrDatas = []
+      stdoutDatas.push(data);
+      logger.debug(data);
+      onStderr(data);
+    });
+    let stderrDatas = [];
     commandProcess.stderr.on("data", (data) => {
-      stderrDatas.push(data)
-      logger.debug(data)
-      onStdout(data)
-    })
+      stderrDatas.push(data);
+      logger.debug(data);
+      onStdout(data);
+    });
     if (commandProcess.stdin) {
       commandProcess.stdin.on("error", (error) => {
-        reject(error)
-      })
+        reject(error);
+      });
     }
     commandProcess.on("exit", (exitCode, signal) => {
       if (signal) {
-        reject(new Error(`killed with ${signal}`))
+        reject(new Error(`killed with ${signal}`));
       }
       if (exitCode) {
         reject(
@@ -64,10 +64,10 @@ export const executeCommand = (
               // "command stdout": stdoutDatas.join(""),
             }),
           ),
-        )
-        return
+        );
+        return;
       }
-      resolve({ exitCode, signal })
-    })
-  })
-}
+      resolve({ exitCode, signal });
+    });
+  });
+};

package/src/helpers/lookup_package_directory.js

@@ -1,34 +1,37 @@
-import { existsSync } from "node:fs"
+import { existsSync } from "node:fs";
 
 export const lookupPackageDirectory = (currentUrl) => {
   if (currentUrl === "file:///") {
-    return null
+    return null;
   }
-  const packageJsonFileUrl = `${currentUrl}package.json`
+  const packageJsonFileUrl = `${currentUrl}package.json`;
   if (existsSync(new URL(packageJsonFileUrl))) {
-    return currentUrl
+    return currentUrl;
   }
-  return lookupPackageDirectory(getParentUrl(currentUrl))
-}
+  return lookupPackageDirectory(getParentUrl(currentUrl));
+};
 
 const getParentUrl = (url) => {
   if (url.startsWith("file://")) {
     // With node.js new URL('../', 'file:///C:/').href
     // returns "file:///C:/" instead of "file:///"
-    const resource = url.slice("file://".length)
-    const slashLastIndex = resource.lastIndexOf("/")
+    const resource = url.slice("file://".length);
+    const slashLastIndex = resource.lastIndexOf("/");
     if (slashLastIndex === -1) {
-      return url
+      return url;
     }
-    const lastCharIndex = resource.length - 1
+    const lastCharIndex = resource.length - 1;
     if (slashLastIndex === lastCharIndex) {
-      const slashBeforeLastIndex = resource.lastIndexOf("/", slashLastIndex - 1)
+      const slashBeforeLastIndex = resource.lastIndexOf(
+        "/",
+        slashLastIndex - 1,
+      );
       if (slashBeforeLastIndex === -1) {
-        return url
+        return url;
       }
-      return `file://${resource.slice(0, slashBeforeLastIndex + 1)}`
+      return `file://${resource.slice(0, slashBeforeLastIndex + 1)}`;
     }
-    return `file://${resource.slice(0, slashLastIndex + 1)}`
+    return `file://${resource.slice(0, slashLastIndex + 1)}`;
   }
-  return new URL(url.endsWith("/") ? "../" : "./", url).href
-}
+  return new URL(url.endsWith("/") ? "../" : "./", url).href;
+};

package/src/helpers/ping_server.js

@@ -1,30 +1,30 @@
-import { createServer } from "node:net"
+import { createServer } from "node:net";
 
 export const pingServer = async (url) => {
-  const server = createServer()
-  const { hostname, port } = new URL(url)
+  const server = createServer();
+  const { hostname, port } = new URL(url);
 
   try {
     await new Promise((resolve, reject) => {
-      server.on("error", reject)
+      server.on("error", reject);
       server.on("listening", () => {
-        resolve()
-      })
-      server.listen(port, hostname)
-    })
+        resolve();
+      });
+      server.listen(port, hostname);
+    });
   } catch (error) {
     if (error && error.code === "EADDRINUSE") {
-      return true
+      return true;
     }
     if (error && error.code === "EACCES") {
-      return true
+      return true;
     }
-    throw error
+    throw error;
   }
   await new Promise((resolve, reject) => {
-    server.on("error", reject)
-    server.on("close", resolve)
-    server.close()
-  })
-  return false
-}
+    server.on("error", reject);
+    server.on("close", resolve);
+    server.close();
+  });
+  return false;
+};

package/src/helpers/require_from_jsenv.js

@@ -1,3 +1,3 @@
-import { createRequire } from "node:module"
+import { createRequire } from "node:module";
 
-export const requireFromJsenv = createRequire(import.meta.url)
+export const requireFromJsenv = createRequire(import.meta.url);

package/src/helpers/watch_source_files.js

@@ -1,4 +1,4 @@
-import { registerDirectoryLifecycle } from "@jsenv/filesystem"
+import { registerDirectoryLifecycle } from "@jsenv/filesystem";
 
 export const watchSourceFiles = (
   sourceDirectoryUrl,
@@ -19,7 +19,7 @@ export const watchSourceFiles = (
     "**/.*/": false, // directory starting with a dot -> do not watch
     "**/node_modules/": false, // node_modules directory -> do not watch
     ...sourceFileConfig,
-  }
+  };
   const stopWatchingSourceFiles = registerDirectoryLifecycle(
     sourceDirectoryUrl,
     {
@@ -31,22 +31,22 @@ export const watchSourceFiles = (
         callback({
           url: new URL(relativeUrl, sourceDirectoryUrl).href,
           event: "added",
-        })
+        });
       },
       updated: ({ relativeUrl }) => {
         callback({
           url: new URL(relativeUrl, sourceDirectoryUrl).href,
           event: "modified",
-        })
+        });
       },
       removed: ({ relativeUrl }) => {
         callback({
           url: new URL(relativeUrl, sourceDirectoryUrl).href,
           event: "removed",
-        })
+        });
       },
     },
-  )
-  stopWatchingSourceFiles.watchPatterns = watchPatterns
-  return stopWatchingSourceFiles
-}
+  );
+  stopWatchingSourceFiles.watchPatterns = watchPatterns;
+  return stopWatchingSourceFiles;
+};

package/src/helpers/web_url_converter.js

@@ -1,5 +1,5 @@
-import { ensureWindowsDriveLetter } from "@jsenv/filesystem"
-import { urlIsInsideOf, moveUrl } from "@jsenv/urls"
+import { ensureWindowsDriveLetter } from "@jsenv/filesystem";
+import { urlIsInsideOf, moveUrl } from "@jsenv/urls";
 
 export const WEB_URL_CONVERTER = {
   asWebUrl: (fileUrl, webServer) => {
@@ -8,21 +8,21 @@ export const WEB_URL_CONVERTER = {
         url: fileUrl,
         from: webServer.rootDirectoryUrl,
         to: `${webServer.origin}/`,
-      })
+      });
     }
-    const fsRootUrl = ensureWindowsDriveLetter("file:///", fileUrl)
-    return `${webServer.origin}/@fs/${fileUrl.slice(fsRootUrl.length)}`
+    const fsRootUrl = ensureWindowsDriveLetter("file:///", fileUrl);
+    return `${webServer.origin}/@fs/${fileUrl.slice(fsRootUrl.length)}`;
   },
   asFileUrl: (webUrl, webServer) => {
-    const { pathname, search } = new URL(webUrl)
+    const { pathname, search } = new URL(webUrl);
     if (pathname.startsWith("/@fs/")) {
-      const fsRootRelativeUrl = pathname.slice("/@fs/".length)
-      return `file:///${fsRootRelativeUrl}${search}`
+      const fsRootRelativeUrl = pathname.slice("/@fs/".length);
+      return `file:///${fsRootRelativeUrl}${search}`;
     }
     return moveUrl({
       url: webUrl,
       from: `${webServer.origin}/`,
       to: webServer.rootDirectoryUrl,
-    })
+    });
   },
-}
+};