@jsenv/core 23.11.1 → 24.1.0-alpha.0

package/src/{startExploring.js → dev_server.js}

@@ -3,6 +3,7 @@ import {
   collectFiles,
   urlToRelativeUrl,
 } from "@jsenv/filesystem"
+import { setupRoutes } from "@jsenv/server"
 
 import { jsenvCoreDirectoryUrl } from "./internal/jsenvCoreDirectoryUrl.js"
 import {
@@ -25,12 +26,24 @@ import {
 } from "./internal/jsenvInternalFiles.js"
 import { jsenvRuntimeSupportDuringDev } from "./jsenvRuntimeSupportDuringDev.js"
 
-export const startExploring = async ({
+export const startDevServer = async ({
   signal = new AbortController().signal,
   handleSIGINT = true,
+  port,
+  ip,
+  protocol,
+  http2,
+  certificate,
+  privateKey,
+  plugins,
+  customServices,
 
-  explorableConfig = jsenvExplorableConfig,
   projectDirectoryUrl,
+  explorableConfig = jsenvExplorableConfig,
+  mainFileRelativeUrl = urlToRelativeUrl(
+    jsenvExploringIndexHtmlFileInfo.url,
+    projectDirectoryUrl,
+  ),
   jsenvDirectoryRelativeUrl,
   outDirectoryName = "dev",
   jsenvToolbar = true,
@@ -40,18 +53,11 @@ export const startExploring = async ({
 
   babelPluginMap,
   runtimeSupportDuringDev = jsenvRuntimeSupportDuringDev,
-  compileServerLogLevel,
+  logLevel,
   compileServerCanReadFromFilesystem,
   compileServerCanWriteOnFilesystem,
-  compileServerPort,
-  compileServerProtocol,
-  compileServerHttp2,
-  compileServerCertificate,
-  compileServerPrivateKey,
   sourcemapMethod,
-  customServices,
   customCompilers,
-  serverPlugins,
   livereloadWatchConfig,
   jsenvDirectoryClean,
 }) => {
@@ -67,6 +73,7 @@ export const startExploring = async ({
   const redirectFiles = createRedirectFilesService({
     projectDirectoryUrl,
     outDirectoryRelativeUrl,
+    mainFileRelativeUrl,
   })
   const serveExploringData = createExploringDataService({
     projectDirectoryUrl,
@@ -84,30 +91,31 @@ export const startExploring = async ({
     signal,
     handleSIGINT,
     keepProcessAlive,
+    logLevel,
+    port,
+    ip,
+    protocol,
+    http2,
+    certificate,
+    privateKey,
+    plugins,
+    customServices: {
+      ...customServices,
+      "jsenv:redirector": redirectFiles,
+      "jsenv:exploring-data": serveExploringData,
+      "jsenv:explorables": serveExplorableListAsJson,
+    },
 
     projectDirectoryUrl,
     livereloadSSE: livereloading,
     jsenvToolbarInjection: jsenvToolbar,
-    customServices: {
-      ...customServices,
-      "service:exploring-redirect": (request) => redirectFiles(request),
-      "service:exploring-data": (request) => serveExploringData(request),
-      "service:explorables": (request) => serveExplorableListAsJson(request),
-    },
-    customCompilers,
-    serverPlugins,
     jsenvDirectoryRelativeUrl,
     outDirectoryName,
     inlineImportMapIntoHTML,
 
-    compileServerLogLevel,
     compileServerCanReadFromFilesystem,
     compileServerCanWriteOnFilesystem,
-    compileServerPort,
-    compileServerProtocol,
-    compileServerHttp2,
-    compileServerCertificate,
-    compileServerPrivateKey,
+    customCompilers,
     sourcemapMethod,
     babelPluginMap,
     runtimeSupport: runtimeSupportDuringDev,
@@ -118,7 +126,10 @@ export const startExploring = async ({
   return compileServer
 }
 
-const createRedirectFilesService = ({ projectDirectoryUrl }) => {
+const createRedirectFilesService = ({
+  projectDirectoryUrl,
+  mainFileRelativeUrl,
+}) => {
   const jsenvExploringRedirectorHtmlRelativeUrlForProject = urlToRelativeUrl(
     jsenvExploringRedirectorHtmlFileInfo.url,
     projectDirectoryUrl,
@@ -136,31 +147,28 @@ const createRedirectFilesService = ({ projectDirectoryUrl }) => {
     projectDirectoryUrl,
   )
 
-  // unfortunately browser resolves sourcemap to url before redirection (not after).
-  // It means browser tries to load source map from "/.jsenv/jsenv-toolbar.js.map"
-  // we could also inline sourcemap but it's not yet possible
-  // inside buildProject
-  const jsenvExploringIndexSourcemapInfo = {
-    pathForBrowser: `/.jsenv/jsenv_exploring_index.js.map`,
-    pathForServer: `/${jsenvExploringJsBuildRelativeUrlForProject}.map`,
-  }
-  const jsenvToolbarSourcemapInfo = {
-    pathForBrowser: `/.jsenv/jsenv_toolbar.js.map`,
-    pathForServer: `/${jsenvToolbarJsBuildRelativeUrlForProject}.map`,
-  }
-
-  return (request) => {
-    // exploring redirection
-    if (request.ressource === "/") {
-      const jsenvExploringRedirectorHtmlServerUrl = `${request.origin}/${jsenvExploringRedirectorHtmlRelativeUrlForProject}`
+  return setupRoutes({
+    "/": (request) => {
+      const redirectTarget = mainFileRelativeUrl
+      const jsenvExploringRedirectorHtmlServerUrl = `${request.origin}/${jsenvExploringRedirectorHtmlRelativeUrlForProject}?redirect=${redirectTarget}`
       return {
         status: 307,
         headers: {
           location: jsenvExploringRedirectorHtmlServerUrl,
         },
       }
-    }
-    if (request.ressource === "/.jsenv/exploring.redirector.js") {
+    },
+    "/.jsenv/redirect/:rest*": (request) => {
+      const redirectTarget = request.ressource.slice("/.jsenv/redirect/".length)
+      const jsenvExploringRedirectorHtmlServerUrl = `${request.origin}/${jsenvExploringRedirectorHtmlRelativeUrlForProject}?redirect=${redirectTarget}`
+      return {
+        status: 307,
+        headers: {
+          location: jsenvExploringRedirectorHtmlServerUrl,
+        },
+      }
+    },
+    "/.jsenv/exploring.redirector.js": (request) => {
       const jsenvExploringRedirectorBuildServerUrl = `${request.origin}/${jsenvExploringRedirectorJsBuildRelativeUrlForProject}`
       return {
         status: 307,
@@ -168,10 +176,8 @@ const createRedirectFilesService = ({ projectDirectoryUrl }) => {
           location: jsenvExploringRedirectorBuildServerUrl,
         },
       }
-    }
-
-    // exploring index
-    if (request.ressource === "/.jsenv/exploring.index.js") {
+    },
+    "/.jsenv/exploring.index.js": (request) => {
       const jsenvExploringJsBuildServerUrl = `${request.origin}/${jsenvExploringJsBuildRelativeUrlForProject}`
       return {
         status: 307,
@@ -179,37 +185,37 @@ const createRedirectFilesService = ({ projectDirectoryUrl }) => {
           location: jsenvExploringJsBuildServerUrl,
         },
       }
-    }
-    if (request.ressource === jsenvExploringIndexSourcemapInfo.pathForBrowser) {
+    },
+    "/.jsenv/toolbar.main.js": (request) => {
+      const jsenvToolbarJsBuildServerUrl = `${request.origin}/${jsenvToolbarJsBuildRelativeUrlForProject}`
       return {
         status: 307,
         headers: {
-          location: `${request.origin}${jsenvExploringIndexSourcemapInfo.pathForServer}`,
+          location: jsenvToolbarJsBuildServerUrl,
         },
       }
-    }
-
-    // toolbar
-    if (request.ressource === "/.jsenv/toolbar.main.js") {
-      const jsenvToolbarJsBuildServerUrl = `${request.origin}/${jsenvToolbarJsBuildRelativeUrlForProject}`
+    },
+    // unfortunately browser resolves sourcemap to url before redirection (not after).
+    // It means browser tries to load source map from "/.jsenv/jsenv-toolbar.js.map"
+    // we could also inline sourcemap but it's not yet possible
+    // inside buildProject
+    "/.jsenv/jsenv_exploring_index.js.map": (request) => {
       return {
         status: 307,
         headers: {
-          location: jsenvToolbarJsBuildServerUrl,
+          location: `${request.origin}/${jsenvExploringJsBuildRelativeUrlForProject}.map`,
         },
       }
-    }
-    if (request.ressource === jsenvToolbarSourcemapInfo.pathForBrowser) {
+    },
+    "/.jsenv/jsenv_toolbar.js.map": (request) => {
       return {
         status: 307,
         headers: {
-          location: `${request.origin}${jsenvToolbarSourcemapInfo.pathForServer}`,
+          location: `${request.origin}/${jsenvToolbarJsBuildRelativeUrlForProject}.map`,
         },
       }
-    }
-
-    return null
-  }
+    },
+  })
 }
 
 const createExploringDataService = ({

package/src/execute.js

@@ -39,11 +39,11 @@ export const execute = async ({
   gracefulStopAllocatedMs,
   ignoreError = false,
 
-  compileServerProtocol,
-  compileServerPrivateKey,
-  compileServerCertificate,
-  compileServerIp,
-  compileServerPort,
+  protocol,
+  privateKey,
+  certificate,
+  ip,
+  port,
   babelPluginMap,
   customCompilers,
   compileServerCanReadFromFilesystem,
@@ -94,7 +94,7 @@ export const execute = async ({
       stop,
     } = await startCompileServer({
       signal: executeOperation.signal,
-      compileServerLogLevel,
+      logLevel: compileServerLogLevel,
 
       projectDirectoryUrl,
       jsenvDirectoryRelativeUrl,
@@ -103,11 +103,11 @@ export const execute = async ({
 
       importDefaultExtension,
 
-      compileServerProtocol,
-      compileServerPrivateKey,
-      compileServerCertificate,
-      compileServerIp,
-      compileServerPort,
+      protocol,
+      privateKey,
+      certificate,
+      ip,
+      port,
       babelPluginMap,
       customCompilers,
       runtimeSupport: normalizeRuntimeSupport({

package/src/executeTestPlan.js

@@ -62,11 +62,11 @@ export const executeTestPlan = async ({
   // skip full means file with 100% coverage won't appear in coverage reports (log and html)
   coverageSkipFull = false,
 
-  compileServerProtocol,
-  compileServerPrivateKey,
-  compileServerCertificate,
-  compileServerIp,
-  compileServerPort,
+  protocol,
+  privateKey,
+  certificate,
+  ip,
+  port,
   compileServerCanReadFromFilesystem,
   compileServerCanWriteOnFilesystem,
   babelPluginMap,
@@ -133,6 +133,7 @@ export const executeTestPlan = async ({
     handleSIGINT,
 
     logger,
+    logLevel,
     compileServerLogLevel,
     launchAndExecuteLogLevel,
 
@@ -157,11 +158,11 @@ export const executeTestPlan = async ({
     coverageTempDirectoryRelativeUrl,
 
     jsenvDirectoryClean,
-    compileServerProtocol,
-    compileServerPrivateKey,
-    compileServerCertificate,
-    compileServerIp,
-    compileServerPort,
+    protocol,
+    privateKey,
+    certificate,
+    ip,
+    port,
     compileServerCanReadFromFilesystem,
     compileServerCanWriteOnFilesystem,
     babelPluginMap,

package/src/internal/compiling/compile-directory/getOrGenerateCompiledFile.js

@@ -127,8 +127,7 @@ const computeCompileReport = async ({
       logger.warn(`WARNING: meta.sources is empty for ${compiledFileUrl}`)
     }
 
-    const metaIsValid = cacheValidity.meta.isValid
-
+    const metaIsValid = cacheValidity.meta ? cacheValidity.meta.isValid : false
     const [compileTiming, compileResult] = await timeFunction("compile", () =>
       callCompile({
         logger,

package/src/internal/compiling/compile-directory/validateCache.js

@@ -20,6 +20,11 @@ export const validateCache = async ({
 }) => {
   const validity = { isValid: true }
 
+  // disable cahce for html files so that we always parse the importmap file
+  if (compiledFileUrl.endsWith(".html")) {
+    return { isValid: false }
+  }
+
   const metaJsonFileUrl = `${compiledFileUrl}__asset__meta.json`
   const metaValidity = await validateMetaFile(metaJsonFileUrl)
   mergeValidity(validity, "meta", metaValidity)

package/src/internal/compiling/compileFile.js

@@ -5,6 +5,7 @@ import {
   bufferToEtag,
   urlIsInsideOf,
 } from "@jsenv/filesystem"
+import { normalizeImportMap, resolveImport } from "@jsenv/importmap"
 import { convertFileSystemErrorToResponseProperties } from "@jsenv/server/src/internal/convertFileSystemErrorToResponseProperties.js"
 
 import { getOrGenerateCompiledFile } from "./compile-directory/getOrGenerateCompiledFile.js"
@@ -19,6 +20,7 @@ export const compileFile = async ({
   projectFileRequestedCallback = () => {},
   request,
   pushResponse,
+  importmapInfos,
   compile,
   compileCacheStrategy,
   compileCacheSourcesValidation,
@@ -106,30 +108,34 @@ export const compileFile = async ({
       )
     })
 
-    if (
-      request.http2 &&
+    if (request.http2) {
       // js resolution is special, we cannot just do resolveUrl of the import specifier
       // because there can be importmap (bare specifier, import without extension, custom remapping, ...)
       // And we would push 404 to the browser
       // Until we implement import map resolution pushing ressource for js imports is disabled
-      compileResult.contentType !== "application/javascript"
-    ) {
-      compileResult.dependencies.forEach((dependency) => {
-        const requestUrl = resolveUrl(request.ressource, request.origin)
-        const dependencyUrl = resolveUrl(dependency, requestUrl)
-        if (!urlIsInsideOf(dependencyUrl, request.origin)) {
-          // ignore external urls
-          return
-        }
-        if (dependencyUrl.startsWith("data:")) {
-          return
-        }
-        const dependencyRelativeUrl = urlToRelativeUrl(
-          dependencyUrl,
-          request.origin,
-        )
-        pushResponse({ path: `/${dependencyRelativeUrl}` })
+      const dependencyResolver = getDependencyResolver({
+        compileResult,
+        importmapInfos,
+        request,
+        projectDirectoryUrl,
       })
+      if (dependencyResolver) {
+        compileResult.dependencies.forEach((dependency) => {
+          const dependencyUrl = dependencyResolver.resolve(dependency)
+          if (!urlIsInsideOf(dependencyUrl, request.origin)) {
+            // ignore external urls
+            return
+          }
+          if (dependencyUrl.startsWith("data:")) {
+            return
+          }
+          const dependencyRelativeUrl = urlToRelativeUrl(
+            dependencyUrl,
+            request.origin,
+          )
+          pushResponse({ path: `/${dependencyRelativeUrl}` })
+        })
+      }
     }
 
     // when a compiled version of the source file was just created or updated
@@ -229,3 +235,62 @@ export const compileFile = async ({
     return convertFileSystemErrorToResponseProperties(error)
   }
 }
+
+const getDependencyResolver = ({
+  compileResult,
+  importmapInfos,
+  request,
+  projectDirectoryUrl,
+}) => {
+  const importmapKeys = Object.keys(importmapInfos)
+  const requestUrl = resolveUrl(request.ressource, request.origin)
+
+  if (
+    compileResult.contentType !== "application/javascript" ||
+    importmapKeys.length === 0
+  ) {
+    return {
+      type: "url_resolution",
+      resolve: (dependency) => {
+        const dependencyUrl = resolveUrl(dependency, requestUrl)
+        return dependencyUrl
+      },
+    }
+  }
+
+  const firstImportmapInfo = importmapInfos[importmapKeys[0]]
+  if (!firstImportmapInfo.text) {
+    return null
+  }
+
+  if (
+    // we are aware only of 1 importmap
+    importmapKeys.length === 1 ||
+    // all importmaps are the same
+    importmapKeys.slice(1).every(({ url }) => url === firstImportmapInfo.url)
+  ) {
+    const importMapBaseUrl = resolveUrl(
+      urlToRelativeUrl(firstImportmapInfo.url, projectDirectoryUrl),
+      `${request.origin}/`,
+    )
+    const importMap = normalizeImportMap(
+      JSON.parse(firstImportmapInfo.text),
+      importMapBaseUrl,
+    )
+    return {
+      type: "importmap_resolution",
+      resolve: (dependency) => {
+        const dependencyUrl = resolveImport({
+          specifier: dependency,
+          importer: requestUrl,
+          importMap,
+        })
+        return dependencyUrl
+      },
+    }
+  }
+
+  // there is more than 2 importmaps, we cannot know which one to pick
+  // (not supposed ot happen because during dev you usually use a single importmap)
+  return null
+}

package/src/internal/compiling/createCompiledFileService.js

@@ -80,6 +80,8 @@ export const createCompiledFileService = ({
     projectDirectoryUrl,
   )
 
+  const importmapInfos = {}
+
   return (request, { pushResponse, redirectRequest }) => {
     const { origin, ressource } = request
     // we use "ressourceToPathname" to remove eventual query param from the url
@@ -167,6 +169,7 @@ export const createCompiledFileService = ({
       projectFileRequestedCallback,
       request,
       pushResponse,
+      importmapInfos,
       compile: ({ code }) => {
         return compiler({
           logger,
@@ -195,6 +198,9 @@ export const createCompiledFileService = ({
           sourcemapMethod,
           sourcemapExcludeSources,
           jsenvToolbarInjection,
+          onHtmlImportmapInfo: ({ htmlUrl, importmapInfo }) => {
+            importmapInfos[htmlUrl] = importmapInfo
+          },
         })
       },
     })
@@ -234,36 +240,40 @@ const getCompiler = ({ originalFileUrl, compileMeta }) => {
   // there is a custom compiler and potentially a jsenv compiler
   return async (params) => {
     // do custom compilation first
-    const customResult = await customCompiler(params)
+    const customCompilerReturnValue = await customCompiler(params)
     // then check if jsenv compiler should apply
     // to the new result contentType
     const jsenvCompilerAfterCustomCompilation =
       getJsenvCompilerAfterCustomCompilation({
         url: originalFileUrl,
-        contentType: customResult.contentType,
         compileMeta,
+        customCompilerReturnValue,
       })
     if (!jsenvCompilerAfterCustomCompilation) {
-      return customResult
+      return customCompilerReturnValue
     }
-    const jsenvResult = await jsenvCompilerAfterCustomCompilation({
+    const jsenvCompilerReturnValue = await jsenvCompilerAfterCustomCompilation({
       ...params,
-      code: customResult.compiledSource,
-      map: customResult.sourcemap,
+      code: customCompilerReturnValue.compiledSource,
+      map: customCompilerReturnValue.sourcemap,
     })
     return {
-      ...customResult,
-      ...jsenvResult,
+      ...customCompilerReturnValue,
+      ...jsenvCompilerReturnValue,
     }
   }
 }
 
 const getJsenvCompilerAfterCustomCompilation = ({
   url,
-  contentType,
   compileMeta,
+  customCompilerReturnValue,
 }) => {
-  const extensionToForce = contentTypeExtensions[contentType]
+  if (customCompilerReturnValue.isBuild) {
+    return null
+  }
+  const extensionToForce =
+    contentTypeExtensions[customCompilerReturnValue.contentType]
   const urlForcingExtension = extensionToForce
     ? setUrlExtension(url, extensionToForce)
     : url