@jsenv/core 20.3.2 → 21.0.0

package/src/internal/compiling/jsenvCompilerForHtml.js

@@ -1,4 +1,3 @@
-import { urlToContentType } from "@jsenv/server"
 import { resolveUrl, urlToRelativeUrl } from "@jsenv/filesystem"
 
 import {
@@ -9,7 +8,6 @@ import {
 import { getDefaultImportMap } from "@jsenv/core/src/internal/import-resolution/importmap-default.js"
 import { setJavaScriptSourceMappingUrl } from "../sourceMappingURLUtils.js"
 import { transformJs } from "./js-compilation-service/transformJs.js"
-import { compileIdToBabelPluginMap } from "./jsenvCompilerForJavaScript.js"
 import {
   parseHtmlString,
   parseHtmlAstRessources,
@@ -25,30 +23,24 @@ import {
 } from "./compileHtml.js"
 import { generateCompiledFileAssetUrl } from "./compile-directory/compile-asset.js"
 
-const compileHtmlFile = ({
+export const compileHtml = async ({
   // cancellationToken,
   // logger,
   // request,
-
+  code,
+  url,
+  compiledUrl,
   projectDirectoryUrl,
   outDirectoryRelativeUrl,
-  originalFileUrl,
-  compiledFileUrl,
   compileId,
-  groupMap,
-  babelPluginMap,
-  convertMap,
+
   transformTopLevelAwait,
   moduleOutFormat,
   importMetaFormat,
+  babelPluginMap,
 
   jsenvToolbarInjection,
 }) => {
-  const contentType = urlToContentType(originalFileUrl)
-  if (contentType !== "text/html") {
-    return null
-  }
-
   const jsenvBrowserBuildUrlRelativeToProject = urlToRelativeUrl(
     jsenvBrowserSystemFileInfo.jsenvBuildUrl,
     projectDirectoryUrl,
@@ -58,189 +50,160 @@ const compileHtmlFile = ({
     projectDirectoryUrl,
   )
 
-  return {
-    compile: async (htmlBeforeCompilation) => {
-      // ideally we should try/catch html syntax error
-      const htmlAst = parseHtmlString(htmlBeforeCompilation)
+  // ideally we should try/catch html syntax error
+  const htmlAst = parseHtmlString(code)
 
-      if (moduleOutFormat !== "esmodule") {
-        await mutateRessourceHints(htmlAst)
-      }
+  if (moduleOutFormat !== "esmodule") {
+    await mutateRessourceHints(htmlAst)
+  }
 
-      manipulateHtmlAst(htmlAst, {
-        scriptInjections: [
-          {
-            src: `/${jsenvBrowserBuildUrlRelativeToProject}`,
-          },
-          ...(jsenvToolbarInjection &&
-          originalFileUrl !== jsenvToolbarHtmlFileInfo.url
-            ? [
-                {
-                  src: `/${jsenvToolbarInjectorBuildRelativeUrlForProject}`,
-                },
-              ]
-            : []),
-        ],
-      })
+  manipulateHtmlAst(htmlAst, {
+    scriptInjections: [
+      {
+        src: `/${jsenvBrowserBuildUrlRelativeToProject}`,
+      },
+      ...(jsenvToolbarInjection && url !== jsenvToolbarHtmlFileInfo.url
+        ? [
+            {
+              src: `/${jsenvToolbarInjectorBuildRelativeUrlForProject}`,
+            },
+          ]
+        : []),
+    ],
+  })
 
-      const { scripts } = parseHtmlAstRessources(htmlAst)
+  const { scripts } = parseHtmlAstRessources(htmlAst)
 
-      let hasImportmap = false
-      const inlineScriptsContentMap = {}
-      scripts.forEach((script) => {
-        const typeAttribute = getHtmlNodeAttributeByName(script, "type")
-        const srcAttribute = getHtmlNodeAttributeByName(script, "src")
+  let hasImportmap = false
+  const inlineScriptsContentMap = {}
+  scripts.forEach((script) => {
+    const typeAttribute = getHtmlNodeAttributeByName(script, "type")
+    const srcAttribute = getHtmlNodeAttributeByName(script, "src")
 
-        // remote
-        if (
-          typeAttribute &&
-          typeAttribute.value === "importmap" &&
-          srcAttribute
-        ) {
-          hasImportmap = true
-          typeAttribute.value = "jsenv-importmap"
-          return
-        }
-        if (typeAttribute && typeAttribute.value === "module" && srcAttribute) {
-          removeHtmlNodeAttribute(script, typeAttribute)
-          removeHtmlNodeAttribute(script, srcAttribute)
-          setHtmlNodeText(
-            script,
-            `window.__jsenv__.executeFileUsingSystemJs(${JSON.stringify(
-              srcAttribute.value,
-            )})`,
-          )
-          return
-        }
-        // inline
-        const textNode = getHtmlNodeTextNode(script)
-        if (typeAttribute && typeAttribute.value === "module" && textNode) {
-          const scriptAssetUrl = generateCompiledFileAssetUrl(
-            compiledFileUrl,
-            getUniqueNameForInlineHtmlNode(script, scripts, `[id].js`),
-          )
-          const specifier = `./${urlToRelativeUrl(
-            scriptAssetUrl,
-            compiledFileUrl,
-          )}`
-          inlineScriptsContentMap[specifier] = textNode.value
+    // remote
+    if (typeAttribute && typeAttribute.value === "importmap" && srcAttribute) {
+      hasImportmap = true
+      typeAttribute.value = "jsenv-importmap"
+      return
+    }
+    if (typeAttribute && typeAttribute.value === "module" && srcAttribute) {
+      removeHtmlNodeAttribute(script, typeAttribute)
+      removeHtmlNodeAttribute(script, srcAttribute)
+      setHtmlNodeText(
+        script,
+        `window.__jsenv__.executeFileUsingSystemJs(${JSON.stringify(
+          srcAttribute.value,
+        )})`,
+      )
+      return
+    }
+    // inline
+    const textNode = getHtmlNodeTextNode(script)
+    if (typeAttribute && typeAttribute.value === "module" && textNode) {
+      const scriptAssetUrl = generateCompiledFileAssetUrl(
+        compiledUrl,
+        getUniqueNameForInlineHtmlNode(script, scripts, `[id].js`),
+      )
+      const specifier = `./${urlToRelativeUrl(scriptAssetUrl, compiledUrl)}`
+      inlineScriptsContentMap[specifier] = textNode.value
 
-          removeHtmlNodeAttribute(script, typeAttribute)
-          removeHtmlNodeAttribute(script, srcAttribute)
-          setHtmlNodeText(
-            script,
-            `window.__jsenv__.executeFileUsingSystemJs(${JSON.stringify(
-              specifier,
-            )})`,
-          )
-          return
-        }
-      })
-      if (hasImportmap === false) {
-        const defaultImportMap = getDefaultImportMap({
-          importMapFileUrl: compiledFileUrl,
-          projectDirectoryUrl,
-          compileDirectoryRelativeUrl: `${outDirectoryRelativeUrl}${compileId}/`,
-        })
+      removeHtmlNodeAttribute(script, typeAttribute)
+      removeHtmlNodeAttribute(script, srcAttribute)
+      setHtmlNodeText(
+        script,
+        `window.__jsenv__.executeFileUsingSystemJs(${JSON.stringify(
+          specifier,
+        )})`,
+      )
+      return
+    }
+  })
+  if (hasImportmap === false) {
+    const defaultImportMap = getDefaultImportMap({
+      importMapFileUrl: compiledUrl,
+      projectDirectoryUrl,
+      compileDirectoryRelativeUrl: `${outDirectoryRelativeUrl}${compileId}/`,
+    })
 
-        manipulateHtmlAst(htmlAst, {
-          scriptInjections: [
-            {
-              type: "jsenv-importmap",
-              // in case there is no importmap, force the presence
-              // so that '@jsenv/core/' are still remapped
-              text: JSON.stringify(defaultImportMap, null, "  "),
-            },
-          ],
-        })
-      }
+    manipulateHtmlAst(htmlAst, {
+      scriptInjections: [
+        {
+          type: "jsenv-importmap",
+          // in case there is no importmap, force the presence
+          // so that '@jsenv/core/' are still remapped
+          text: JSON.stringify(defaultImportMap, null, "  "),
+        },
+      ],
+    })
+  }
 
-      const htmlAfterTransformation = stringifyHtmlAst(htmlAst)
+  const htmlAfterTransformation = stringifyHtmlAst(htmlAst)
 
-      let assets = []
-      let assetsContent = []
-      await Promise.all(
-        Object.keys(inlineScriptsContentMap).map(async (scriptSrc) => {
-          const scriptAssetUrl = resolveUrl(scriptSrc, compiledFileUrl)
-          const scriptBasename = urlToRelativeUrl(
-            scriptAssetUrl,
-            compiledFileUrl,
-          )
-          const scriptOriginalFileUrl = resolveUrl(
-            scriptBasename,
-            originalFileUrl,
-          )
-          const scriptAfterTransformFileUrl = resolveUrl(
-            scriptBasename,
-            compiledFileUrl,
-          )
+  let assets = []
+  let assetsContent = []
+  await Promise.all(
+    Object.keys(inlineScriptsContentMap).map(async (scriptSrc) => {
+      const scriptAssetUrl = resolveUrl(scriptSrc, compiledUrl)
+      const scriptBasename = urlToRelativeUrl(scriptAssetUrl, compiledUrl)
+      const scriptOriginalFileUrl = resolveUrl(scriptBasename, url)
+      const scriptCompiledFileUrl = resolveUrl(scriptBasename, compiledUrl)
 
-          const scriptBeforeCompilation = inlineScriptsContentMap[scriptSrc]
-          let scriptTransformResult
-          try {
-            scriptTransformResult = await transformJs({
-              code: scriptBeforeCompilation,
-              url: scriptOriginalFileUrl,
-              urlAfterTransform: scriptAfterTransformFileUrl,
-              projectDirectoryUrl,
+      const scriptBeforeCompilation = inlineScriptsContentMap[scriptSrc]
+      let scriptTransformResult
+      try {
+        scriptTransformResult = await transformJs({
+          code: scriptBeforeCompilation,
+          url: scriptOriginalFileUrl,
+          compiledUrl: scriptCompiledFileUrl,
+          projectDirectoryUrl,
 
-              babelPluginMap: compileIdToBabelPluginMap(compileId, {
-                groupMap,
-                babelPluginMap,
-              }),
-              convertMap,
-              transformTopLevelAwait,
-              moduleOutFormat,
-              importMetaFormat,
-            })
-          } catch (e) {
-            // If there is a syntax error in inline script
-            // we put the raw script without transformation.
-            // when systemjs will try to instantiate to script it
-            // will re-throw this syntax error.
-            // Thanks to this we see the syntax error in the
-            // document and livereloading still works
-            // because we gracefully handle this error
-            if (e.code === "PARSE_ERROR") {
-              const code = scriptBeforeCompilation
-              assets = [...assets, scriptAssetUrl]
-              assetsContent = [...assetsContent, code]
-              return
-            }
-            throw e
-          }
-          const sourcemapFileUrl = resolveUrl(
-            `${scriptBasename}.map`,
-            scriptAfterTransformFileUrl,
-          )
+          transformTopLevelAwait,
+          moduleOutFormat,
+          importMetaFormat,
+          babelPluginMap,
+        })
+      } catch (e) {
+        // If there is a syntax error in inline script
+        // we put the raw script without transformation.
+        // when systemjs will try to instantiate to script it
+        // will re-throw this syntax error.
+        // Thanks to this we see the syntax error in the
+        // document and livereloading still works
+        // because we gracefully handle this error
+        if (e.code === "PARSE_ERROR") {
+          const code = scriptBeforeCompilation
+          assets = [...assets, scriptAssetUrl]
+          assetsContent = [...assetsContent, code]
+          return
+        }
+        throw e
+      }
+      const sourcemapFileUrl = resolveUrl(
+        `${scriptBasename}.map`,
+        scriptCompiledFileUrl,
+      )
 
-          let { code, map } = scriptTransformResult
-          const sourcemapFileRelativePathForModule = urlToRelativeUrl(
-            sourcemapFileUrl,
-            compiledFileUrl,
-          )
-          code = setJavaScriptSourceMappingUrl(
-            code,
-            sourcemapFileRelativePathForModule,
-          )
-          assets = [...assets, scriptAssetUrl, sourcemapFileUrl]
-          assetsContent = [
-            ...assetsContent,
-            code,
-            JSON.stringify(map, null, "  "),
-          ]
-        }),
+      let { code, map } = scriptTransformResult
+      const sourcemapFileRelativePathForModule = urlToRelativeUrl(
+        sourcemapFileUrl,
+        compiledUrl,
+      )
+      code = setJavaScriptSourceMappingUrl(
+        code,
+        sourcemapFileRelativePathForModule,
       )
+      assets = [...assets, scriptAssetUrl, sourcemapFileUrl]
+      assetsContent = [...assetsContent, code, JSON.stringify(map, null, "  ")]
+    }),
+  )
 
-      return {
-        compiledSource: htmlAfterTransformation,
-        contentType: "text/html",
-        sources: [originalFileUrl],
-        sourcesContent: [htmlBeforeCompilation],
-        assets,
-        assetsContent,
-      }
-    },
+  return {
+    contentType: "text/html",
+    compiledSource: htmlAfterTransformation,
+    sources: [url],
+    sourcesContent: [code],
+    assets,
+    assetsContent,
   }
 }
 
@@ -304,7 +267,3 @@ const mutateRessourceHints = async (htmlAst) => {
   )
   mutations.forEach((mutation) => mutation())
 }
-
-export const jsenvCompilerForHtml = {
-  "jsenv-compiler-html": compileHtmlFile,
-}

package/src/internal/compiling/jsenvCompilerForImportmap.js

@@ -1,22 +1,88 @@
-import { urlToContentType } from "@jsenv/server"
-import { transformImportmap } from "./transformImportmap.js"
+/**
+ * allows the following:
+ *
+ * import "@jsenv/core/helpers/regenerator-runtime/regenerator-runtime.js"
+ * -> searches a file inside @jsenv/core/*
+ *
+ */
 
-const compileImportmapFile = ({ originalFileUrl }) => {
-  const contentType = urlToContentType(originalFileUrl)
+import { urlToRelativeUrl, urlIsInsideOf } from "@jsenv/filesystem"
+import { composeTwoImportMaps } from "@jsenv/import-map"
+import { jsenvCoreDirectoryUrl } from "../jsenvCoreDirectoryUrl.js"
 
-  if (contentType !== "application/importmap+json") {
-    return null
+export const compileImportmap = async ({ code, url }) => {
+  const importMapForProject = JSON.parse(code)
+
+  const topLevelRemappingForJsenvCore = {
+    "@jsenv/core/": urlToRelativeUrlRemapping(jsenvCoreDirectoryUrl, url),
+  }
+
+  const importmapForSelfImport = {
+    imports: topLevelRemappingForJsenvCore,
+    scopes: generateJsenvCoreScopes({
+      importMapForProject,
+      topLevelRemappingForJsenvCore,
+    }),
   }
 
+  const importMap = [importmapForSelfImport, importMapForProject].reduce(
+    (previous, current) => composeTwoImportMaps(previous, current),
+    {},
+  )
+
+  const scopes = importMap.scopes || {}
+  const projectTopLevelMappings = importMapForProject.imports || {}
+  Object.keys(scopes).forEach((scope) => {
+    const scopedMappings = scopes[scope]
+    Object.keys(projectTopLevelMappings).forEach((key) => {
+      if (key in scopedMappings) {
+        scopedMappings[key] = projectTopLevelMappings[key]
+      }
+    })
+  })
+
   return {
-    compile: (importmapBeforeTransformation) => {
-      return transformImportmap(importmapBeforeTransformation, {
-        originalFileUrl,
-      })
-    },
+    contentType: "application/importmap+json",
+    compiledSource: JSON.stringify(importMap, null, "  "),
+    sources: [url],
+    sourcesContent: [code],
+    assets: [],
+    assetsContent: [],
   }
 }
 
-export const jsenvCompilerForImportmap = {
-  "jsenv-compiler-importmap": compileImportmapFile,
+// this function just here to ensure relative urls starts with './'
+// so that importmap do not consider them as bare specifiers
+const urlToRelativeUrlRemapping = (url, baseUrl) => {
+  const relativeUrl = urlToRelativeUrl(url, baseUrl)
+
+  if (urlIsInsideOf(url, baseUrl)) {
+    if (relativeUrl.startsWith("../")) return relativeUrl
+    if (relativeUrl.startsWith("./")) return relativeUrl
+    return `./${relativeUrl}`
+  }
+
+  return relativeUrl
+}
+
+const generateJsenvCoreScopes = ({
+  importMapForProject,
+  topLevelRemappingForJsenvCore,
+}) => {
+  const { scopes } = importMapForProject
+
+  if (!scopes) {
+    return undefined
+  }
+
+  // I must ensure jsenvCoreImports wins by default in every scope
+  // because scope may contains stuff like
+  // "/": "/"
+  // "/": "/folder/"
+  // to achieve this, we set jsenvCoreImports into every scope
+  const scopesForJsenvCore = {}
+  Object.keys(scopes).forEach((scopeKey) => {
+    scopesForJsenvCore[scopeKey] = topLevelRemappingForJsenvCore
+  })
+  return scopesForJsenvCore
 }

package/src/internal/compiling/jsenvCompilerForJavaScript.js

@@ -1,84 +1,47 @@
-import { urlToContentType } from "@jsenv/server"
 import { transformJs } from "./js-compilation-service/transformJs.js"
 import { transformResultToCompilationResult } from "./transformResultToCompilationResult.js"
 
-const compileJsFile = ({
+export const compileJavascript = async ({
+  code,
+  map,
+  url,
+  compiledUrl,
   projectDirectoryUrl,
-  originalFileUrl,
-  compiledFileUrl,
-  compileId,
-  groupMap,
+
   babelPluginMap,
-  convertMap,
   transformTopLevelAwait,
   moduleOutFormat,
   importMetaFormat,
-  writeOnFilesystem,
+
   sourcemapExcludeSources,
 }) => {
-  const contentType = urlToContentType(originalFileUrl)
-
-  if (
-    contentType !== "application/javascript" &&
-    contentType !== "text/javascript"
-  ) {
-    return null
-  }
-
-  return {
-    compile: async (originalFileContent) => {
-      const transformResult = await transformJs({
-        code: originalFileContent,
-        url: originalFileUrl,
-        urlAfterTransform: compiledFileUrl,
-        projectDirectoryUrl,
-
-        babelPluginMap: compileIdToBabelPluginMap(compileId, {
-          groupMap,
-          babelPluginMap,
-        }),
-        convertMap,
-        transformTopLevelAwait,
-        moduleOutFormat,
-        importMetaFormat,
-      })
-      const sourcemapFileUrl = `${compiledFileUrl}.map`
-
-      return transformResultToCompilationResult(transformResult, {
-        projectDirectoryUrl,
-        originalFileContent,
-        originalFileUrl,
-        compiledFileUrl,
-        sourcemapFileUrl,
-        sourcemapMethod: writeOnFilesystem ? "comment" : "inline",
-        sourcemapExcludeSources,
-      })
+  const transformResult = await transformJs({
+    code,
+    map,
+    url,
+    compiledUrl,
+    projectDirectoryUrl,
+
+    babelPluginMap,
+    transformTopLevelAwait,
+    moduleOutFormat,
+    importMetaFormat,
+  })
+
+  return transformResultToCompilationResult(
+    {
+      contentType: "application/javascript",
+      code: transformResult.code,
+      map: transformResult.map,
+      metadata: transformResult.metadata,
     },
-  }
-}
-
-export const jsenvCompilerForJavaScript = {
-  "jsenv-compiler-js": compileJsFile,
-}
-
-export const compileIdToBabelPluginMap = (
-  compileId,
-  { babelPluginMap, groupMap },
-) => {
-  const babelPluginMapForGroupMap = {}
-
-  const groupBabelPluginMap = {}
-  groupMap[compileId].babelPluginRequiredNameArray.forEach(
-    (babelPluginRequiredName) => {
-      if (babelPluginRequiredName in babelPluginMap) {
-        groupBabelPluginMap[babelPluginRequiredName] =
-          babelPluginMap[babelPluginRequiredName]
-      }
+    {
+      projectDirectoryUrl,
+      originalFileContent: code,
+      originalFileUrl: url,
+      compiledFileUrl: compiledUrl,
+      sourcemapFileUrl: `${compiledUrl}.map`,
+      sourcemapExcludeSources,
     },
   )
-
-  return {
-    ...groupBabelPluginMap,
-    ...babelPluginMapForGroupMap,
-  }
 }

package/src/internal/compiling/startCompileServer.js

@@ -72,7 +72,6 @@ export const startCompileServer = async ({
   replaceGlobalDirname = false,
   replaceMap = {},
   babelPluginMap = jsenvBabelPluginMap,
-  convertMap = {},
   customCompilers = {},
 
   // options related to the server itself
@@ -201,7 +200,6 @@ export const startCompileServer = async ({
     importDefaultExtension,
     compileServerGroupMap,
     env,
-    convertMap,
     inlineImportMapIntoHTML,
     customCompilers,
   })
@@ -272,7 +270,6 @@ export const startCompileServer = async ({
       transformTopLevelAwait,
       groupMap: compileServerGroupMap,
       babelPluginMap,
-      convertMap,
       customCompilers,
       moduleOutFormat,
       importMetaFormat,
@@ -874,7 +871,6 @@ const createOutJSONFiles = ({
   importDefaultExtension,
   compileServerGroupMap,
   babelPluginMap,
-  convertMap,
   replaceProcessEnvNodeEnv,
   processEnvNodeEnv,
   env,
@@ -897,7 +893,6 @@ const createOutJSONFiles = ({
   const outDirectoryMeta = {
     jsenvCorePackageVersion,
     babelPluginMap,
-    convertMap,
     compileServerGroupMap,
     replaceProcessEnvNodeEnv,
     processEnvNodeEnv,
@@ -914,8 +909,7 @@ const createOutJSONFiles = ({
     outDirectoryRelativeUrl,
     importDefaultExtension,
     inlineImportMapIntoHTML,
-    customCompilerNames: Object.keys(customCompilers),
-    convertPatterns: Object.keys(convertMap),
+    customCompilerPatterns: Object.keys(customCompilers),
   }
   outJSONFiles.env = {
     url: envOutFileUrl,