@jsenv/core 31.1.4 → 32.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "31.1.4",
+  "version": "32.0.0",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "author": {
@@ -69,16 +69,16 @@
     "@jsenv/abort": "4.2.4",
     "@jsenv/ast": "3.0.3",
     "@jsenv/babel-plugins": "1.1.5",
-    "@jsenv/filesystem": "4.2.0",
+    "@jsenv/filesystem": "4.2.1",
     "@jsenv/importmap": "1.2.1",
     "@jsenv/integrity": "0.0.1",
     "@jsenv/log": "3.3.4",
     "@jsenv/node-esm-resolution": "1.0.1",
-    "@jsenv/plugin-bundling": "2.1.0",
-    "@jsenv/server": "15.0.0",
+    "@jsenv/plugin-bundling": "2.1.1",
+    "@jsenv/server": "15.0.1",
     "@jsenv/sourcemap": "1.0.9",
     "@jsenv/uneval": "1.6.0",
-    "@jsenv/url-meta": "7.1.0",
+    "@jsenv/url-meta": "8.0.0",
     "@jsenv/urls": "1.2.8",
     "@jsenv/utils": "2.0.1",
     "@paralleldrive/cuid2": "2.2.0",

package/src/basic_fetch.js

@@ -0,0 +1,42 @@
+export const basicFetch = async (
+  url,
+  { method = "GET", headers = {} } = {},
+) => {
+  let requestModule
+  if (url.startsWith("http:")) {
+    requestModule = await import("node:http")
+  } else {
+    requestModule = await import("node:https")
+  }
+  const { request } = requestModule
+
+  const urlObject = new URL(url)
+
+  return new Promise((resolve, reject) => {
+    const req = request({
+      hostname: urlObject.hostname,
+      port: urlObject.port,
+      path: urlObject.pathname,
+      method,
+      headers,
+    })
+    req.on("response", (response) => {
+      req.setTimeout(0)
+      let responseBody = ""
+      response.setEncoding("utf8")
+      response.on("data", (chunk) => {
+        responseBody += chunk
+      })
+      response.on("end", () => {
+        req.destroy()
+        if (response.headers["content-type"] === "application/json") {
+          resolve(JSON.parse(responseBody))
+        } else {
+          resolve(responseBody)
+        }
+      })
+    })
+    req.on("error", reject)
+    req.end()
+  })
+}

package/src/build/build.js

@@ -28,10 +28,9 @@ import {
   urlToRelativeUrl,
 } from "@jsenv/urls"
 import {
-  validateDirectoryUrl,
+  assertAndNormalizeDirectoryUrl,
   ensureEmptyDirectory,
   writeFileSync,
-  registerDirectoryLifecycle,
   comparePathnames,
 } from "@jsenv/filesystem"
 import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
@@ -54,6 +53,8 @@ import {
   findHtmlNode,
 } from "@jsenv/ast"
 
+import { determineJsenvInternalDirectoryUrl } from "../jsenv_internal_directory.js"
+import { watchSourceFiles } from "../watch_source_files.js"
 import { createUrlGraph } from "../kitchen/url_graph.js"
 import { createKitchen } from "../kitchen/kitchen.js"
 import { RUNTIME_COMPAT } from "../kitchen/compat/runtime_compat.js"
@@ -94,12 +95,13 @@ export const defaultRuntimeCompat = {
 /**
  * Generate an optimized version of source files into a directory
  * @param {Object} buildParameters
- * @param {string|url} buildParameters.rootDirectoryUrl
+ * @param {string|url} buildParameters.sourceDirectoryUrl
  *        Directory containing source files
+ * @param {object} buildParameters.entryPoints
+ *        Object where keys are paths to source files and values are their future name in the build directory.
+ *        Keys are relative to sourceDirectoryUrl
  * @param {string|url} buildParameters.buildDirectoryUrl
  *        Directory where optimized files will be written
- * @param {object} buildParameters.entryPoints
- *        Describe entry point paths and control their names in the build directory
  * @param {object} buildParameters.runtimeCompat
  *        Code generated will be compatible with these runtimes
  * @param {string} [buildParameters.assetsDirectory=""]
@@ -124,10 +126,10 @@ export const build = async ({
   signal = new AbortController().signal,
   handleSIGINT = true,
   logLevel = "info",
-  rootDirectoryUrl,
+  sourceDirectoryUrl,
+  entryPoints = {},
   buildDirectoryUrl,
   assetsDirectory = "",
-  entryPoints = {},
 
   runtimeCompat = defaultRuntimeCompat,
   base = runtimeCompat.node ? "./" : "/",
@@ -145,9 +147,7 @@ export const build = async ({
   versioningViaImportmap = true,
   lineBreakNormalization = process.platform === "win32",
 
-  clientFiles = {
-    "./src/": true,
-  },
+  sourceFilesConfig = {},
   cooldownBetweenFileEvents,
   watch = false,
 
@@ -166,20 +166,42 @@ export const build = async ({
         `${unexpectedParamNames.join(",")}: there is no such param`,
       )
     }
-    const rootDirectoryUrlValidation = validateDirectoryUrl(rootDirectoryUrl)
-    if (!rootDirectoryUrlValidation.valid) {
-      throw new TypeError(
-        `rootDirectoryUrl ${rootDirectoryUrlValidation.message}, got ${rootDirectoryUrl}`,
-      )
+    sourceDirectoryUrl = assertAndNormalizeDirectoryUrl(
+      sourceDirectoryUrl,
+      "sourceDirectoryUrl",
+    )
+
+    if (typeof entryPoints !== "object" || entryPoints === null) {
+      throw new TypeError(`entryPoints must be an object, got ${entryPoints}`)
     }
-    rootDirectoryUrl = rootDirectoryUrlValidation.value
-    const buildDirectoryUrlValidation = validateDirectoryUrl(buildDirectoryUrl)
-    if (!buildDirectoryUrlValidation.valid) {
+    const keys = Object.keys(entryPoints)
+    keys.forEach((key) => {
+      if (!key.startsWith("./")) {
+        throw new TypeError(
+          `entryPoints keys must start with "./", found ${key}`,
+        )
+      }
+      const value = entryPoints[key]
+      if (typeof value !== "string") {
+        throw new TypeError(
+          `entryPoints values must be strings, found "${value}" on key "${key}"`,
+        )
+      }
+      if (value.includes("/")) {
+        throw new TypeError(
+          `entryPoints values must be plain strings (no "/"), found "${value}" on key "${key}"`,
+        )
+      }
+    })
+    buildDirectoryUrl = assertAndNormalizeDirectoryUrl(
+      buildDirectoryUrl,
+      "buildDirectoryUrl",
+    )
+    if (!["filename", "search_param"].includes(versioningMethod)) {
       throw new TypeError(
-        `buildDirectoryUrl ${buildDirectoryUrlValidation.message}, got ${buildDirectoryUrlValidation}`,
+        `versioningMethod must be "filename" or "search_param", got ${versioning}`,
       )
     }
-    buildDirectoryUrl = buildDirectoryUrlValidation.value
   }
 
   const operation = Abort.startOperation()
@@ -195,12 +217,6 @@ export const build = async ({
     })
   }
 
-  assertEntryPoints({ entryPoints })
-  if (!["filename", "search_param"].includes(versioningMethod)) {
-    throw new Error(
-      `Unexpected "versioningMethod": must be "filename", "search_param"; got ${versioning}`,
-    )
-  }
   if (assetsDirectory && assetsDirectory[assetsDirectory.length - 1] !== "/") {
     assetsDirectory = `${assetsDirectory}/`
   }
@@ -211,11 +227,14 @@ export const build = async ({
       directoryToClean = new URL(assetsDirectory, buildDirectoryUrl).href
     }
   }
+  const jsenvInternalDirectoryUrl =
+    determineJsenvInternalDirectoryUrl(sourceDirectoryUrl)
+
   const asFormattedBuildUrl = (generatedUrl, reference) => {
     if (base === "./") {
       const urlRelativeToParent = urlToRelativeUrl(
         generatedUrl,
-        reference.parentUrl === rootDirectoryUrl
+        reference.parentUrl === sourceDirectoryUrl
           ? buildDirectoryUrl
           : reference.parentUrl,
       )
@@ -279,7 +298,8 @@ build ${entryPointKeys.length} entry points`)
     const rawGraphKitchen = createKitchen({
       signal,
       logLevel,
-      rootDirectoryUrl,
+      rootDirectoryUrl: sourceDirectoryUrl,
+      jsenvInternalDirectoryUrl,
       urlGraph: rawGraph,
       build: true,
       runtimeCompat,
@@ -304,7 +324,7 @@ build ${entryPointKeys.length} entry points`)
           },
         },
         ...getCorePlugins({
-          rootDirectoryUrl,
+          rootDirectoryUrl: sourceDirectoryUrl,
           urlGraph: rawGraph,
           runtimeCompat,
 
@@ -323,7 +343,7 @@ build ${entryPointKeys.length} entry points`)
       sourcemaps,
       sourcemapsSourcesContent,
       writeGeneratedFiles,
-      outDirectoryUrl: new URL(`.jsenv/build/`, rootDirectoryUrl),
+      outDirectoryUrl: new URL("build/", jsenvInternalDirectoryUrl),
     })
 
     const buildUrlsGenerator = createBuildUrlsGenerator({
@@ -347,12 +367,13 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
     const bundlers = {}
     const finalGraph = createUrlGraph()
     const urlAnalysisPlugin = jsenvPluginUrlAnalysis({
-      rootDirectoryUrl,
+      rootDirectoryUrl: sourceDirectoryUrl,
       ...urlAnalysis,
     })
     const finalGraphKitchen = createKitchen({
       logLevel,
       rootDirectoryUrl: buildDirectoryUrl,
+      jsenvInternalDirectoryUrl,
       urlGraph: finalGraph,
       build: true,
       runtimeCompat,
@@ -643,7 +664,7 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
       sourcemapsSourcesContent,
       sourcemapsSourcesRelative: !versioning,
       writeGeneratedFiles,
-      outDirectoryUrl: new URL(".jsenv/postbuild/", rootDirectoryUrl),
+      outDirectoryUrl: new URL("postbuild/", jsenvInternalDirectoryUrl),
     })
     const finalEntryUrls = []
 
@@ -653,7 +674,7 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
       })
       try {
         if (writeGeneratedFiles) {
-          await ensureEmptyDirectory(new URL(`.jsenv/build/`, rootDirectoryUrl))
+          await ensureEmptyDirectory(new URL(`build/`, sourceDirectoryUrl))
         }
         const rawUrlGraphLoader = createUrlGraphLoader(
           rawGraphKitchen.kitchenContext,
@@ -662,7 +683,7 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
           const [entryReference, entryUrlInfo] =
             rawGraphKitchen.kitchenContext.prepareEntryPoint({
               trace: { message: `"${key}" in entryPoints parameter` },
-              parentUrl: rootDirectoryUrl,
+              parentUrl: sourceDirectoryUrl,
               type: "entry_point",
               specifier: key,
             })
@@ -899,7 +920,7 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
         try {
           if (writeGeneratedFiles) {
             await ensureEmptyDirectory(
-              new URL(`.jsenv/postbuild/`, rootDirectoryUrl),
+              new URL(`postbuild/`, jsenvInternalDirectoryUrl),
             )
           }
           const finalUrlGraphLoader = createUrlGraphLoader(
@@ -909,7 +930,7 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
             const [finalEntryReference, finalEntryUrlInfo] =
               finalGraphKitchen.kitchenContext.prepareEntryPoint({
                 trace: { message: `entryPoint` },
-                parentUrl: rootDirectoryUrl,
+                parentUrl: sourceDirectoryUrl,
                 type: "entry_point",
                 specifier: entryUrl,
               })
@@ -1128,6 +1149,7 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
           const versioningKitchen = createKitchen({
             logLevel: logger.level,
             rootDirectoryUrl: buildDirectoryUrl,
+            jsenvInternalDirectoryUrl,
             urlGraph: finalGraph,
             build: true,
             runtimeCompat,
@@ -1244,10 +1266,7 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
             sourcemapsSourcesContent,
             sourcemapsSourcesRelative: true,
             writeGeneratedFiles,
-            outDirectoryUrl: new URL(
-              ".jsenv/postbuild/",
-              finalGraphKitchen.rootDirectoryUrl,
-            ),
+            outDirectoryUrl: new URL("postbuild/", jsenvInternalDirectoryUrl),
           })
           const versioningUrlGraphLoader = createUrlGraphLoader(
             versioningKitchen.kitchenContext,
@@ -1686,39 +1705,33 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
 
   startBuild()
   let startTimeout
-  const clientFileChangeCallback = ({ relativeUrl, event }) => {
-    const url = new URL(relativeUrl, rootDirectoryUrl).href
-    if (watchFilesTask) {
-      watchFilesTask.happen(`${url.slice(rootDirectoryUrl.length)} ${event}`)
-      watchFilesTask = null
-    }
-    buildAbortController.abort()
-    // setTimeout is to ensure the abortController.abort() above
-    // is properly taken into account so that logs about abort comes first
-    // then logs about re-running the build happens
-    clearTimeout(startTimeout)
-    startTimeout = setTimeout(startBuild, 20)
-  }
-  const stopWatchingClientFiles = registerDirectoryLifecycle(rootDirectoryUrl, {
-    watchPatterns: clientFiles,
-    cooldownBetweenFileEvents,
-    keepProcessAlive: true,
-    recursive: true,
-    added: ({ relativeUrl }) => {
-      clientFileChangeCallback({ relativeUrl, event: "added" })
-    },
-    updated: ({ relativeUrl }) => {
-      clientFileChangeCallback({ relativeUrl, event: "modified" })
+  const stopWatchingSourceFiles = watchSourceFiles(
+    sourceDirectoryUrl,
+    ({ url, event }) => {
+      if (watchFilesTask) {
+        watchFilesTask.happen(
+          `${url.slice(sourceDirectoryUrl.length)} ${event}`,
+        )
+        watchFilesTask = null
+      }
+      buildAbortController.abort()
+      // setTimeout is to ensure the abortController.abort() above
+      // is properly taken into account so that logs about abort comes first
+      // then logs about re-running the build happens
+      clearTimeout(startTimeout)
+      startTimeout = setTimeout(startBuild, 20)
     },
-    removed: ({ relativeUrl }) => {
-      clientFileChangeCallback({ relativeUrl, event: "removed" })
+    {
+      sourceFilesConfig,
+      keepProcessAlive: true,
+      cooldownBetweenFileEvents,
     },
-  })
+  )
   operation.addAbortCallback(() => {
-    stopWatchingClientFiles()
+    stopWatchingSourceFiles()
   })
   await firstBuildPromise
-  return stopWatchingClientFiles
+  return stopWatchingSourceFiles
 }
 
 const findKey = (map, value) => {
@@ -1743,31 +1756,6 @@ const injectVersionIntoBuildUrl = ({ buildUrl, version, versioningMethod }) => {
   return versionedUrl
 }
 
-const assertEntryPoints = ({ entryPoints }) => {
-  if (typeof entryPoints !== "object" || entryPoints === null) {
-    throw new TypeError(`entryPoints must be an object, got ${entryPoints}`)
-  }
-  const keys = Object.keys(entryPoints)
-  keys.forEach((key) => {
-    if (!key.startsWith("./")) {
-      throw new TypeError(
-        `unexpected key in entryPoints, all keys must start with ./ but found ${key}`,
-      )
-    }
-    const value = entryPoints[key]
-    if (typeof value !== "string") {
-      throw new TypeError(
-        `unexpected value in entryPoints, all values must be strings found ${value} for key ${key}`,
-      )
-    }
-    if (value.includes("/")) {
-      throw new TypeError(
-        `unexpected value in entryPoints, all values must be plain strings (no "/") but found ${value} for key ${key}`,
-      )
-    }
-  })
-}
-
 const isUsed = (urlInfo) => {
   // nothing uses this url anymore
   // - versioning update inline content

package/src/build/start_build_server.js

@@ -14,7 +14,6 @@
  */
 
 import { existsSync } from "node:fs"
-import { parentPort } from "node:worker_threads"
 import {
   jsenvAccessControlAllowedHeaders,
   startServer,
@@ -22,46 +21,32 @@ import {
   jsenvServiceCORS,
   jsenvServiceErrorHandler,
 } from "@jsenv/server"
-import {
-  validateDirectoryUrl,
-  registerDirectoryLifecycle,
-} from "@jsenv/filesystem"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 import { createLogger, createTaskLog } from "@jsenv/log"
-import { getCallerPosition } from "@jsenv/urls"
-
-import { createReloadableWorker } from "@jsenv/core/src/helpers/worker_reload.js"
 
 /**
  * Start a server for build files.
  * @param {Object} buildServerParameters
- * @param {string|url} buildServerParameters.rootDirectoryUrl Root directory of the project
  * @param {string|url} buildServerParameters.buildDirectoryUrl Directory where build files are written
  * @return {Object} A build server object
  */
 export const startBuildServer = async ({
-  signal = new AbortController().signal,
-  handleSIGINT = true,
-  logLevel,
-  serverLogLevel = "warn",
-  https,
-  http2,
-  acceptAnyIp,
-  hostname,
+  buildDirectoryUrl,
+  buildMainFilePath = "index.html",
   port = 9779,
   services = [],
+  acceptAnyIp,
+  hostname,
+  https,
+  http2,
+  logLevel,
+  serverLogLevel = "warn",
+
+  signal = new AbortController().signal,
+  handleSIGINT = true,
   keepProcessAlive = true,
 
-  rootDirectoryUrl,
-  buildDirectoryUrl,
-  buildIndexPath = "index.html",
-  buildServerFiles = {
-    "./package.json": true,
-    "./jsenv.config.mjs": true,
-  },
-  buildServerAutoreload = false,
-  buildServerMainFile = getCallerPosition().url,
-  cooldownBetweenFileEvents,
   ...rest
 }) => {
   // params validation
@@ -72,40 +57,31 @@ export const startBuildServer = async ({
         `${unexpectedParamNames.join(",")}: there is no such param`,
       )
     }
-    const rootDirectoryUrlValidation = validateDirectoryUrl(rootDirectoryUrl)
-    if (!rootDirectoryUrlValidation.valid) {
-      throw new TypeError(
-        `rootDirectoryUrl ${rootDirectoryUrlValidation.message}, got ${rootDirectoryUrl}`,
-      )
-    }
-    rootDirectoryUrl = rootDirectoryUrlValidation.value
-    const buildDirectoryUrlValidation = validateDirectoryUrl(buildDirectoryUrl)
-    if (!buildDirectoryUrlValidation.valid) {
-      throw new TypeError(
-        `buildDirectoryUrl ${buildDirectoryUrlValidation.message}, got ${buildDirectoryUrlValidation}`,
-      )
-    }
-    buildDirectoryUrl = buildDirectoryUrlValidation.value
+    buildDirectoryUrl = assertAndNormalizeDirectoryUrl(
+      buildDirectoryUrl,
+      "buildDirectoryUrl",
+    )
 
-    if (buildIndexPath) {
-      if (typeof buildIndexPath !== "string") {
+    if (buildMainFilePath) {
+      if (typeof buildMainFilePath !== "string") {
         throw new TypeError(
-          `buildIndexPath must be a string, got ${buildIndexPath}`,
+          `buildMainFilePath must be a string, got ${buildMainFilePath}`,
         )
       }
-      if (buildIndexPath[0] === "/") {
-        buildIndexPath = buildIndexPath.slice(1)
+      if (buildMainFilePath[0] === "/") {
+        buildMainFilePath = buildMainFilePath.slice(1)
       } else {
-        const buildIndexUrl = new URL(buildIndexPath, buildDirectoryUrl).href
-        if (!buildIndexUrl.startsWith(buildDirectoryUrl)) {
+        const buildMainFileUrl = new URL(buildMainFilePath, buildDirectoryUrl)
+          .href
+        if (!buildMainFileUrl.startsWith(buildDirectoryUrl)) {
           throw new Error(
-            `buildIndexPath must be relative, got ${buildIndexPath}`,
+            `buildMainFilePath must be relative, got ${buildMainFilePath}`,
           )
         }
-        buildIndexPath = buildIndexUrl.slice(buildDirectoryUrl.length)
+        buildMainFilePath = buildMainFileUrl.slice(buildDirectoryUrl.length)
       }
-      if (!existsSync(new URL(buildIndexPath, buildDirectoryUrl))) {
-        buildIndexPath = null
+      if (!existsSync(new URL(buildMainFilePath, buildDirectoryUrl))) {
+        buildMainFilePath = null
       }
     }
   }
@@ -124,59 +100,6 @@ export const startBuildServer = async ({
     })
   }
 
-  let reloadableWorker
-  if (buildServerAutoreload) {
-    reloadableWorker = createReloadableWorker(buildServerMainFile)
-    if (reloadableWorker.isPrimary) {
-      const buildServerFileChangeCallback = ({ relativeUrl, event }) => {
-        const url = new URL(relativeUrl, rootDirectoryUrl).href
-        logger.info(`file ${event} ${url} -> restarting server...`)
-        reloadableWorker.reload()
-      }
-      const stopWatchingBuildServerFiles = registerDirectoryLifecycle(
-        rootDirectoryUrl,
-        {
-          watchPatterns: {
-            ...buildServerFiles,
-            [buildServerMainFile]: true,
-            ".jsenv/": false,
-          },
-          cooldownBetweenFileEvents,
-          keepProcessAlive: false,
-          recursive: true,
-          added: ({ relativeUrl }) => {
-            buildServerFileChangeCallback({ relativeUrl, event: "added" })
-          },
-          updated: ({ relativeUrl }) => {
-            buildServerFileChangeCallback({ relativeUrl, event: "modified" })
-          },
-          removed: ({ relativeUrl }) => {
-            buildServerFileChangeCallback({ relativeUrl, event: "removed" })
-          },
-        },
-      )
-      operation.addAbortCallback(() => {
-        stopWatchingBuildServerFiles()
-        reloadableWorker.terminate()
-      })
-      const worker = await reloadableWorker.load()
-      const messagePromise = new Promise((resolve) => {
-        worker.once("message", resolve)
-      })
-      const origin = await messagePromise
-      // if (!keepProcessAlive) {
-      //   worker.unref()
-      // }
-      return {
-        origin,
-        stop: () => {
-          stopWatchingBuildServerFiles()
-          reloadableWorker.terminate()
-        },
-      }
-    }
-  }
-
   const startBuildServerTask = createTaskLog("start build server", {
     disabled: !logger.levels.info,
   })
@@ -211,7 +134,7 @@ export const startBuildServer = async ({
         name: "jsenv:build_files_service",
         handleRequest: createBuildFilesService({
           buildDirectoryUrl,
-          buildIndexPath,
+          buildMainFilePath,
         }),
       },
       jsenvServiceErrorHandler({
@@ -229,9 +152,6 @@ export const startBuildServer = async ({
     logger.info(`- ${server.origins[key]}`)
   })
   logger.info(``)
-  if (reloadableWorker && reloadableWorker.isWorker) {
-    parentPort.postMessage(server.origin)
-  }
   return {
     origin: server.origin,
     stop: () => {
@@ -240,13 +160,13 @@ export const startBuildServer = async ({
   }
 }
 
-const createBuildFilesService = ({ buildDirectoryUrl, buildIndexPath }) => {
+const createBuildFilesService = ({ buildDirectoryUrl, buildMainFilePath }) => {
   return (request) => {
     const urlIsVersioned = new URL(request.url).searchParams.has("v")
-    if (buildIndexPath && request.resource === "/") {
+    if (buildMainFilePath && request.resource === "/") {
       request = {
         ...request,
-        resource: `/${buildIndexPath}`,
+        resource: `/${buildMainFilePath}`,
       }
     }
     return fetchFileSystem(