@jsenv/core 20.3.2 → 21.0.0

package/readme.md

@@ -355,10 +355,10 @@ CommonJS module format rely on `module.exports` and `require`. It was invented b
 _jsenv.config.mjs to use code written in CommonJS_:
 
 ```js
-import { jsenvBabelPluginMap, convertCommonJsWithRollup } from "@jsenv/core"
+import { jsenvBabelPluginMap, commonJsToJavaScriptModule } from "@jsenv/core"
 
-export const convertMap = {
-  "./node_modules/whatever/index.js": convertCommonJsWithRollup,
+export const customCompilers = {
+  "./node_modules/whatever/index.js": commonJsToJavaScriptModule,
 }
 ```
 
@@ -370,7 +370,7 @@ _jsenv.config.mjs for react and jsx:_
 
 ```js
 import { createRequire } from "module"
-import { jsenvBabelPluginMap, convertCommonJsWithRollup } from "@jsenv/core"
+import { jsenvBabelPluginMap, commonJsToJavaScriptModule } from "@jsenv/core"
 
 const require = createRequire(import.meta.url)
 const transformReactJSX = require("@babel/plugin-transform-react-jsx")
@@ -383,10 +383,10 @@ export const babelPluginMap = {
   ],
 }
 
-export const convertMap = {
-  "./node_modules/react/index.js": convertCommonJsWithRollup,
+export const customCompilers = {
+  "./node_modules/react/index.js": commonJsToJavaScriptModule,
   "./node_modules/react-dom/index.js": (options) => {
-    return convertCommonJsWithRollup({ ...options, external: ["react"] })
+    return commonJsToJavaScriptModule({ ...options, external: ["react"] })
   },
 }
 ```
@@ -408,7 +408,7 @@ See also
 
 - [@jsenv/importmap-node-module](https://github.com/jsenv/importmap-node-module#import-map-node-module)
 - [babelPluginMap](./docs/shared-parameters.md#babelPluginMap)
-- [convertMap](./docs/shared-parameters.md#convertMap)
+- [customCompilers](./docs/shared-parameters.md#customCompilers)
 - [transform-react-jsx on babel](https://babeljs.io/docs/en/next/babel-plugin-transform-react-jsx.html)
 - [importmap spec](https://github.com/WICG/import-maps#import-maps)
 

package/src/{convertCommonJsWithRollup.js → commonJsToJavaScriptModule.js}

@@ -1,10 +1,14 @@
 import { urlToFileSystemPath, resolveUrl } from "@jsenv/filesystem"
 
 import { require } from "./internal/require.js"
+import { transformResultToCompilationResult } from "./internal/compiling/transformResultToCompilationResult.js"
 
-export const convertCommonJsWithRollup = async ({
+export const commonJsToJavaScriptModule = async ({
   url,
-  urlAfterTransform,
+  compiledUrl,
+  projectDirectoryUrl,
+
+  sourcemapExcludeSources,
 
   replaceGlobalObject = true,
   replaceGlobalFilename = true,
@@ -92,15 +96,29 @@ export const convertCommonJsWithRollup = async ({
     // https://rollupjs.org/guide/en#output-sourcemap
     sourcemap: true,
     sourcemapExcludeSources: true,
-    ...(urlAfterTransform
-      ? { dir: urlToFileSystemPath(resolveUrl("./", urlAfterTransform)) }
+    ...(compiledUrl
+      ? { dir: urlToFileSystemPath(resolveUrl("./", compiledUrl)) }
       : {}),
   }
 
   const { output } = await rollupBuild.generate(generateOptions)
   const { code, map } = output[0]
 
-  return { code, map }
+  return transformResultToCompilationResult(
+    {
+      contentType: "application/javascript",
+      code,
+      map,
+    },
+    {
+      projectDirectoryUrl,
+      originalFileContent: code,
+      originalFileUrl: url,
+      compiledFileUrl: compiledUrl,
+      sourcemapFileUrl: `${compiledUrl}.map`,
+      sourcemapExcludeSources,
+    },
+  )
 }
 
 const __filenameReplacement = `import.meta.url.slice('file:///'.length)`

package/src/execute.js

@@ -50,7 +50,7 @@ export const execute = async ({
   compileServerIp,
   compileServerPort,
   babelPluginMap,
-  convertMap,
+  customCompilers,
   compileServerCanReadFromFilesystem,
   compileServerCanWriteOnFilesystem,
   runtimeSupportDuringDev = jsenvRuntimeSupportDuringDev,
@@ -95,7 +95,7 @@ export const execute = async ({
       compileServerIp,
       compileServerPort,
       babelPluginMap,
-      convertMap,
+      customCompilers,
       runtimeSupport: runtimeSupportDuringDev,
       compileServerCanReadFromFilesystem,
       compileServerCanWriteOnFilesystem,

package/src/executeTestPlan.js

@@ -77,7 +77,7 @@ export const executeTestPlan = async ({
   compileServerCanReadFromFilesystem,
   compileServerCanWriteOnFilesystem,
   babelPluginMap,
-  convertMap,
+  customCompilers,
   // we could even affine depending on testPlan
   runtimeSupportDuringDev = jsenvRuntimeSupportDuringDev,
   jsenvDirectoryClean,
@@ -185,7 +185,7 @@ export const executeTestPlan = async ({
       compileServerCanReadFromFilesystem,
       compileServerCanWriteOnFilesystem,
       babelPluginMap,
-      convertMap,
+      customCompilers,
       runtimeSupport: runtimeSupportDuringDev,
     })
 

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

@@ -215,21 +215,28 @@ const callCompile = async ({
 }) => {
   logger.debug(`compile ${originalFileUrl}`)
 
-  const compileArgs =
+  const codeBeforeCompile =
     compile.length === 0
-      ? []
-      : await getArgumentsForCompile({ originalFileUrl, fileContentFallback })
+      ? ""
+      : await getCodeToCompile({ originalFileUrl, fileContentFallback })
 
+  const compileReturnValue = await compile({
+    code: codeBeforeCompile,
+    map: undefined,
+  })
+  if (typeof compileReturnValue !== "object" || compileReturnValue === null) {
+    throw new TypeError(
+      `compile must return an object, got ${compileReturnValue}`,
+    )
+  }
   const {
+    contentType,
+    compiledSource,
     sources = [],
     sourcesContent = [],
     assets = [],
     assetsContent = [],
-    contentType,
-    compiledSource,
-    ...rest
-  } = await compile(...compileArgs)
-
+  } = compileReturnValue
   if (typeof contentType !== "string") {
     throw new TypeError(
       `compile must return a contentType string, got ${contentType}`,
@@ -248,14 +255,10 @@ const callCompile = async ({
     sourcesContent,
     assets,
     assetsContent,
-    ...rest,
   }
 }
 
-const getArgumentsForCompile = async ({
-  originalFileUrl,
-  fileContentFallback,
-}) => {
+const getCodeToCompile = async ({ originalFileUrl, fileContentFallback }) => {
   let fileContent
   if (fileContentFallback) {
     try {
@@ -270,7 +273,7 @@ const getArgumentsForCompile = async ({
   } else {
     fileContent = await readFileContent(originalFileUrl)
   }
-  return [fileContent]
+  return fileContent
 }
 
 const startAsap = async (fn, { logger, compiledFileUrl }) => {

package/src/internal/compiling/createCompiledFileService.js

@@ -1,5 +1,10 @@
 import { serveFile } from "@jsenv/server"
-import { resolveUrl, resolveDirectoryUrl } from "@jsenv/filesystem"
+import {
+  resolveUrl,
+  resolveDirectoryUrl,
+  normalizeStructuredMetaMap,
+  urlToMeta,
+} from "@jsenv/filesystem"
 
 import { serverUrlToCompileInfo } from "@jsenv/core/src/internal/url_conversion.js"
 import {
@@ -9,14 +14,19 @@ import {
   COMPILE_ID_BUILD_COMMONJS_FILES,
 } from "../CONSTANTS.js"
 import { compileFile } from "./compileFile.js"
-import { jsenvCompilerForHtml } from "./jsenvCompilerForHtml.js"
-import { jsenvCompilerForImportmap } from "./jsenvCompilerForImportmap.js"
-import { jsenvCompilerForJavaScript } from "./jsenvCompilerForJavaScript.js"
+import { compileHtml } from "./jsenvCompilerForHtml.js"
+import { compileImportmap } from "./jsenvCompilerForImportmap.js"
+import { compileJavascript } from "./jsenvCompilerForJavaScript.js"
 
 const jsenvCompilers = {
-  ...jsenvCompilerForJavaScript,
-  ...jsenvCompilerForHtml,
-  ...jsenvCompilerForImportmap,
+  "**/*.js": compileJavascript,
+  "**/*.jsx": compileJavascript,
+  "**/*.ts": compileJavascript,
+  "**/*.tsx": compileJavascript,
+  "**/*.mjs": compileJavascript,
+
+  "**/*.html": compileHtml,
+  "**/*.importmap": compileImportmap,
 }
 
 export const createCompiledFileService = ({
@@ -33,18 +43,31 @@ export const createCompiledFileService = ({
   importMetaFormat,
   babelPluginMap,
   groupMap,
-  convertMap,
   customCompilers,
-  urlMappings,
 
   jsenvToolbarInjection,
 
   projectFileRequestedCallback,
   useFilesystemAsCache,
-  writeOnFilesystem,
   compileCacheStrategy,
   sourcemapExcludeSources,
 }) => {
+  Object.keys(customCompilers).forEach((key) => {
+    const value = customCompilers[key]
+    if (typeof value !== "function") {
+      throw new TypeError(
+        `Compiler must be a function, found ${value} for "${key}"`,
+      )
+    }
+  })
+  const compileMeta = normalizeStructuredMetaMap(
+    {
+      jsenvCompiler: jsenvCompilers,
+      customCompiler: customCompilers,
+    },
+    projectDirectoryUrl,
+  )
+
   return (request) => {
     const { origin, ressource } = request
     const requestUrl = `${origin}${ressource}`
@@ -103,73 +126,111 @@ export const createCompiledFileService = ({
       compileDirectoryUrl,
     )
 
-    let compilerOptions = null
-    const compilerCandidateParams = {
+    const compiler = getCompiler({ originalFileUrl, compileMeta })
+    // no compiler -> serve original file
+    // we don't redirect otherwise it complexify ressource tracking
+    // and url resolution
+    if (!compiler) {
+      return sourceFileService({
+        ...request,
+        ressource: `/${originalFileRelativeUrl}`,
+      })
+    }
+
+    // compile this if needed
+    const compileResponsePromise = compileFile({
       cancellationToken,
       logger,
 
-      compileServerOrigin: request.origin,
       projectDirectoryUrl,
       originalFileUrl,
       compiledFileUrl,
-      compileId,
-      outDirectoryRelativeUrl,
-
-      urlMappings,
-
-      moduleOutFormat,
-      importMetaFormat,
-      groupMap,
-      babelPluginMap,
-      convertMap,
-      transformTopLevelAwait,
-      runtimeSupport,
 
-      writeOnFilesystem,
-      sourcemapExcludeSources,
-      jsenvToolbarInjection,
-    }
-    const compilerCandidates = { ...jsenvCompilers, ...customCompilers }
-    Object.keys(compilerCandidates).find((compilerCandidateName) => {
-      const compilerCandidate = compilerCandidates[compilerCandidateName]
-      if (typeof compilerCandidate !== "function") {
-        throw new TypeError(
-          `"${compilerCandidateName}" compiler is not a function, got ${compilerCandidate}`,
-        )
-      }
-      const returnValue = compilerCandidate(compilerCandidateParams)
-      if (returnValue && typeof returnValue === "object") {
-        compilerOptions = returnValue
-        return true
-      }
-      return false
+      writeOnFilesystem: true, // we always need them
+      useFilesystemAsCache,
+      compileCacheStrategy,
+      projectFileRequestedCallback,
+      request,
+      compile: ({ code, map }) => {
+        return compiler({
+          cancellationToken,
+          logger,
+
+          code,
+          map,
+          url: originalFileUrl,
+          compiledUrl: compiledFileUrl,
+          projectDirectoryUrl,
+          compileServerOrigin: request.origin,
+          outDirectoryRelativeUrl,
+          compileId,
+
+          runtimeSupport,
+          moduleOutFormat,
+          importMetaFormat,
+          transformTopLevelAwait,
+          babelPluginMap: compileIdToBabelPluginMap(compileId, {
+            babelPluginMap,
+            groupMap,
+          }),
+
+          sourcemapMethod: "comment", // "inline" is also possible
+          sourcemapExcludeSources,
+          jsenvToolbarInjection,
+        })
+      },
     })
+    return compileResponsePromise
+  }
+}
 
-    if (compilerOptions) {
-      return compileFile({
-        cancellationToken,
-        logger,
+const getCompiler = ({ originalFileUrl, compileMeta }) => {
+  const { jsenvCompiler, customCompiler } = urlToMeta({
+    url: originalFileUrl,
+    structuredMetaMap: compileMeta,
+  })
 
-        projectDirectoryUrl,
-        originalFileUrl,
-        compiledFileUrl,
+  if (!jsenvCompiler && !customCompiler) {
+    return null
+  }
 
-        writeOnFilesystem: true, // we always need them
-        useFilesystemAsCache,
-        compileCacheStrategy,
-        projectFileRequestedCallback,
-        request,
+  if (!jsenvCompiler && customCompiler) {
+    return customCompiler
+  }
 
-        ...compilerOptions,
-      })
-    }
+  // there is only a jsenvCompiler
+  if (jsenvCompiler && !customCompiler) {
+    return jsenvCompiler
+  }
 
-    // no compiler -> serve original file
-    // we don't redirect otherwise it complexify ressource tracking
-    // and url resolution
-    return sourceFileService({
-      ...request,
-      ressource: `/${originalFileRelativeUrl}`,
+  // both project and jsenv wants to compile the file
+  // we'll do the custom compilation first, then jsenv compilation
+  return async (params) => {
+    const customResult = await customCompiler(params)
+    const jsenvResult = await jsenvCompiler({
+      ...params,
+      code: customResult.compiledSource,
+      map: customResult.sourcemap,
     })
+    return jsenvResult
+  }
+}
+
+const compileIdToBabelPluginMap = (compileId, { babelPluginMap, groupMap }) => {
+  const babelPluginMapForGroupMap = {}
+
+  const groupBabelPluginMap = {}
+  groupMap[compileId].babelPluginRequiredNameArray.forEach(
+    (babelPluginRequiredName) => {
+      if (babelPluginRequiredName in babelPluginMap) {
+        groupBabelPluginMap[babelPluginRequiredName] =
+          babelPluginMap[babelPluginRequiredName]
+      }
+    },
+  )
+
+  return {
+    ...groupBabelPluginMap,
+    ...babelPluginMapForGroupMap,
   }
 }

package/src/internal/compiling/js-compilation-service/jsenvTransform.js

@@ -14,7 +14,7 @@ import { filePathToBabelHelperName } from "./babelHelper.js"
 
 export const jsenvTransform = async ({
   code,
-  map,
+  map, // optional
   ast, // optional
   url,
   relativeUrl, // optional

package/src/internal/compiling/js-compilation-service/transformJs.js

@@ -1,8 +1,4 @@
-import {
-  urlToRelativeUrl,
-  normalizeStructuredMetaMap,
-  urlToMeta,
-} from "@jsenv/filesystem"
+import { urlToRelativeUrl } from "@jsenv/filesystem"
 
 import { jsenvTransform } from "./jsenvTransform.js"
 
@@ -10,11 +6,9 @@ export const transformJs = async ({
   code,
   map,
   url,
-  urlAfterTransform,
   projectDirectoryUrl,
 
   babelPluginMap,
-  convertMap = {},
   moduleOutFormat = "esmodule",
   importMetaFormat = moduleOutFormat,
   babelHelpersInjectionAsImport = true,
@@ -41,20 +35,6 @@ export const transformJs = async ({
     throw new TypeError(`url must be a string, got ${url}`)
   }
 
-  const conversionResult = await applyConvertMap({
-    code,
-    map,
-    url,
-    urlAfterTransform,
-    projectDirectoryUrl,
-
-    convertMap,
-    sourcemapEnabled,
-    allowTopLevelAwait,
-  })
-  code = conversionResult.code
-  map = conversionResult.map
-
   const transformResult = await jsenvTransform({
     code,
     map,
@@ -79,53 +59,3 @@ export const transformJs = async ({
   const { metadata } = transformResult
   return { code, map, metadata }
 }
-
-const applyConvertMap = async ({
-  code,
-  map,
-  url,
-  urlAfterTransform,
-  projectDirectoryUrl,
-
-  convertMap,
-  remap,
-  allowTopLevelAwait,
-}) => {
-  const structuredMetaMap = normalizeStructuredMetaMap(
-    {
-      convert: convertMap,
-    },
-    projectDirectoryUrl,
-  )
-  const { convert } = urlToMeta({ url, structuredMetaMap })
-  if (!convert) {
-    return { code, map }
-  }
-
-  if (typeof convert !== "function") {
-    throw new TypeError(`convert must be a function, got ${convert}`)
-  }
-  const convertReturnValue = await convert({
-    code,
-    map,
-    url,
-    urlAfterTransform,
-    projectDirectoryUrl,
-
-    remap,
-    allowTopLevelAwait,
-  })
-  if (typeof convertReturnValue !== "object") {
-    throw new TypeError(
-      `convert must return an object, got ${convertReturnValue}`,
-    )
-  }
-  code = convertReturnValue.code
-  map = convertReturnValue.map
-  if (typeof code !== "string") {
-    throw new TypeError(
-      `convert return value "code" property must be a string, got ${code}`,
-    )
-  }
-  return { code, map }
-}