@jsenv/core 20.2.0 → 21.0.0

package/readme.md

@@ -348,6 +348,20 @@ To get a better idea see [jsenv.config.js](./jsenv.config.js). The file can be i
 
 That being said it's only a recommendation. There is nothing enforcing or checking the presence of _jsenv.config.mjs_.
 
+## CommonJS
+
+CommonJS module format rely on `module.exports` and `require`. It was invented by Node.js and is not standard JavaScript. If your code or one of your dependency uses it, it requires some configuration. The jsenv config below makes jsenv compatible with a package named _"whatever"_ that would be written in CommonJS.
+
+_jsenv.config.mjs to use code written in CommonJS_:
+
+```js
+import { jsenvBabelPluginMap, commonJsToJavaScriptModule } from "@jsenv/core"
+
+export const customCompilers = {
+  "./node_modules/whatever/index.js": commonJsToJavaScriptModule,
+}
+```
+
 ## React
 
 React is written in CommonJS and comes with jsx. If you use react and or jsx it requires some configuration.
@@ -356,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")
@@ -369,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"] })
   },
 }
 ```
@@ -394,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)
 
@@ -425,20 +439,6 @@ See also
 - [importDefaultExtension](./docs/shared-parameters.md#importDefaultExtension)
 - [transform-typescript on babel](https://babeljs.io/docs/en/next/babel-plugin-transform-typescript.html)
 
-## CommonJS
-
-CommonJS module format rely on `module.exports` and `require`. It was invented by Node.js and is not standard JavaScript. If your code or one of your dependency uses it, it requires some configuration. The jsenv config below makes jsenv compatible with a package named _"whatever"_ that would be written in CommonJS.
-
-_jsenv.config.mjs to use code written in CommonJS_:
-
-```js
-import { jsenvBabelPluginMap, convertCommonJsWithRollup } from "@jsenv/core"
-
-export const convertMap = {
-  "./node_modules/whatever/index.js": convertCommonJsWithRollup,
-}
-```
-
 # See also
 
 | Link                                                                                                                     | Description                                                         |

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

@@ -1,9 +1,15 @@
 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,
   replaceGlobalDirname = true,
@@ -90,14 +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 result = await rollupBuild.generate(generateOptions)
+  const { output } = await rollupBuild.generate(generateOptions)
+  const { code, map } = output[0]
 
-  return result.output[0]
+  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/building/createJsenvRollupPlugin.js

@@ -33,10 +33,7 @@ import {
 import { importMapsFromHtml } from "./html/htmlScan.js"
 import { parseRessource } from "./parseRessource.js"
 import { fetchSourcemap } from "./fetchSourcemap.js"
-import {
-  createRessourceBuilder,
-  referenceToCodeForRollup,
-} from "./ressource_builder.js"
+import { createRessourceBuilder } from "./ressource_builder.js"
 import { computeBuildRelativeUrl } from "./url-versioning.js"
 import { transformImportMetaUrlReferences } from "./transformImportMetaUrlReferences.js"
 
@@ -429,9 +426,7 @@ building ${entryFileRelativeUrls.length} entry files...`)
             // isRessourceHint,
             ressourceImporter,
           }) => {
-            // Entry point is not a JS module and references a js module
-            // -> html referencing js
-            // we must wait for rollup build to be done to generate the html asset
+            // Entry point is not a JS module and references a js module (html referencing js)
             if (
               ressourceImporter.isEntryPoint &&
               !ressourceImporter.isJsModule &&
@@ -603,10 +598,6 @@ building ${entryFileRelativeUrls.length} entry files...`)
       return asRollupUrl(importUrl)
     },
 
-    // TODO: when code is using new URL() pattern
-    // the code after build is currently returning a string instead of an url object
-    // can we always return an url object because resolveFileUrl is always called
-    // by this pattern?
     resolveFileUrl: ({ referenceId, fileName }) => {
       const ressourceFound = ressourceBuilder.findRessource((ressource) => {
         return ressource.rollupReferenceId === referenceId
@@ -652,6 +643,7 @@ building ${entryFileRelativeUrls.length} entry files...`)
 
       const moduleInfo = this.getModuleInfo(id)
       const url = asServerUrl(id)
+      const importerUrl = urlImporterMap[url]
 
       // logger.debug(`loads ${url}`)
       const {
@@ -664,8 +656,6 @@ building ${entryFileRelativeUrls.length} entry files...`)
         moduleInfo,
       })
 
-      const importerUrl = urlImporterMap[url]
-
       // Jsenv helpers are injected as import statements to provide code like babel helpers
       // For now we just compute the information that the target file is a jsenv helper
       // without doing anything special with "targetIsJsenvHelperFile" information
@@ -675,8 +665,9 @@ building ${entryFileRelativeUrls.length} entry files...`)
         jsenvHelpersDirectoryInfo.url,
       )
 
-      // Store the fact that this file is referenced by js (static or dynamic import)
-      ressourceBuilder.createReference({
+      // Store the fact that this ressource exists
+      // Happens when entry point references js, also for every static and dynamic imports
+      ressourceBuilder.createReferenceFoundByRollup({
         // we don't want to emit a js chunk for every js file found
         // (However we want if the file is preload/prefetch by something else)
         // so we tell asset builder not to emit a chunk for this js reference
@@ -685,7 +676,7 @@ building ${entryFileRelativeUrls.length} entry files...`)
         ressourceContentTypeExpected: responseContentType,
         referenceUrl: importerUrl,
         ressourceSpecifier: responseUrl,
-        // rollup do not provide a way to know line and column for the static or dynamic import
+        // rollup do not expose a way to know line and column for the static or dynamic import
         // referencing that file
         referenceColumn: undefined,
         referenceLine: undefined,
@@ -706,6 +697,8 @@ building ${entryFileRelativeUrls.length} entry files...`)
     },
 
     async transform(codeInput, id) {
+      // we should try/catch here?
+      // because this.parse might fail
       const ast = this.parse(codeInput, {
         // used to know node line and column
         locations: true,
@@ -884,6 +877,8 @@ building ${entryFileRelativeUrls.length} entry files...`)
         const jsRessource = ressourceBuilder.findRessource(
           (ressource) => ressource.url === file.url,
         )
+        // avant buildEnd il se peut que certaines ressources ne soit pas encore inline
+        // donc dans inlinedCallback on voudras ptet delete ces ressources?
         if (jsRessource && jsRessource.isInline) {
           buildInlineFileContents[fileName] = file.code
         } else {
@@ -903,7 +898,7 @@ building ${entryFileRelativeUrls.length} entry files...`)
       // aux assets faisant référence a ces chunk js qu'ils sont terminés
       // et donc les assets peuvent connaitre le nom du chunk
       // et mettre a jour leur dépendance vers ce fichier js
-      ressourceBuilder.buildEnd({ jsModuleBuild, buildManifest })
+      ressourceBuilder.rollupBuildEnd({ jsModuleBuild, buildManifest })
       // wait html files to be emitted
       await ressourceBuilder.getAllEntryPointsEmittedPromise()
 
@@ -960,6 +955,26 @@ building ${entryFileRelativeUrls.length} entry files...`)
       rollupBuild = injectSourcemapInRollupBuild(rollupBuild, {
         buildDirectoryUrl,
       })
+
+      // update rollupBuild, buildInlineFilesContents, buildManifest and buildMappings
+      // in case some ressources where inlined by ressourceBuilder.rollupBuildEnd
+      Object.keys(buildManifest).forEach((fileName) => {
+        const buildRelativeUrl = buildManifest[fileName]
+        const ressource = ressourceBuilder.findRessource(
+          (ressource) => ressource.buildRelativeUrl === buildRelativeUrl,
+        )
+        if (ressource && ressource.isInline) {
+          delete buildManifest[fileName]
+          const originalProjectUrl = asOriginalUrl(ressource.url)
+          delete buildMappings[
+            urlToRelativeUrl(originalProjectUrl, projectDirectoryUrl)
+          ]
+          buildInlineFileContents[buildRelativeUrl] =
+            rollupBuild[buildRelativeUrl].code
+          delete rollupBuild[buildRelativeUrl]
+        }
+      })
+
       rollupBuild = sortObjectByPathnames(rollupBuild)
       buildManifest = sortObjectByPathnames(buildManifest)
       buildMappings = sortObjectByPathnames(buildMappings)
@@ -1022,12 +1037,11 @@ building ${entryFileRelativeUrls.length} entry files...`)
     // },
   ) => {
     if (moduleUrl in inlineModuleScripts) {
-      const codeInput = inlineModuleScripts[moduleUrl]
-
       const { code, map } = await transformJs({
-        projectDirectoryUrl,
-        code: codeInput,
+        code: inlineModuleScripts[moduleUrl],
         url: asProjectUrl(moduleUrl), // transformJs expect a file:// url
+        projectDirectoryUrl,
+
         babelPluginMap,
         // moduleOutFormat: format // we are compiling for rollup output must be "esmodule"
       })
@@ -1087,44 +1101,18 @@ building ${entryFileRelativeUrls.length} entry files...`)
       }
     }
 
-    const moduleResponseBodyAsBuffer = Buffer.from(
-      await moduleResponse.arrayBuffer(),
+    const urlRelativeToImporter = urlToRelativeUrl(moduleUrl, importerUrl)
+    const jsenvPluginError = new Error(
+      `"${responseContentType}" is not a valid type for JavaScript module
+--- js module url ---
+${asOriginalUrl(moduleUrl)}
+--- importer url ---
+${asOriginalUrl(importerUrl)}
+--- suggestion ---
+non-js ressources can be used with new URL("${urlRelativeToImporter}", import.meta.url)`,
     )
-    const contentType = moduleResponse.headers["content-type"]
-    const assetReferenceForImport =
-      await ressourceBuilder.createReferenceFoundInJs({
-        // Reference to this target is corresponds to a static or dynamic import.
-        // found in a given file (importerUrl).
-        // But we don't know the line and colum because rollup
-        // does not tell us that information
-        jsUrl: importerUrl,
-        jsLine: undefined,
-        jsColumn: undefined,
-        ressourceSpecifier: moduleResponse.url,
-
-        contentType,
-        bufferBeforeBuild: moduleResponseBodyAsBuffer,
-      })
-    if (assetReferenceForImport) {
-      markBuildRelativeUrlAsUsedByJs(
-        assetReferenceForImport.ressource.buildRelativeUrl,
-      )
-      const content = `export default ${referenceToCodeForRollup(
-        assetReferenceForImport,
-      )}`
-
-      return {
-        ...commonData,
-        contentRaw: String(moduleResponseBodyAsBuffer),
-        content,
-      }
-    }
-
-    return {
-      ...commonData,
-      contentRaw: String(moduleResponseBodyAsBuffer),
-      content: String(moduleResponseBodyAsBuffer),
-    }
+    storeLatestJsenvPluginError(jsenvPluginError)
+    throw jsenvPluginError
   }
 
   const jsenvFetchUrl = async (url, importer) => {

package/src/internal/building/html/parseHtmlRessource.js

@@ -36,6 +36,7 @@ import {
   parseSrcset,
   stringifySrcset,
   getHtmlNodeLocation,
+  removeHtmlNode,
 } from "@jsenv/core/src/internal/compiling/compileHtml.js"
 import {
   getJavaScriptSourceMappingUrl,
@@ -590,6 +591,10 @@ const linkHrefVisitor = (
         // we could remove the HTML node but better keep it untouched and let user decide what to do
         return
       }
+
+      ressource.inlinedCallbacks.push(() => {
+        removeHtmlNode(link)
+      })
     }
 
     if (ressource.isExternal) {

package/src/internal/building/ressource_builder.js

@@ -51,9 +51,8 @@ export const createRessourceBuilder = (
     entryBuffer,
     entryBuildRelativeUrl,
   }) => {
-    // we don't really know where this reference to that asset file comes from
-    // we could almost say it's from the script calling this function
-    // so we could analyse stack trace here to put this function caller
+    // The entry point is conceptually referenced by code passing "entryPointMap"
+    // to buildProject. So we analyse stack trace to put this function caller
     // as the reference to this ressource file
     const callerLocation = getCallerLocation()
     const entryReference = createReference({
@@ -109,7 +108,14 @@ export const createRessourceBuilder = (
     )
   }
 
-  const createReferenceFoundInJs = async ({
+  const createReferenceFoundByRollup = async (params) => {
+    return createReference({
+      fromRollup: true,
+      ...params,
+    })
+  }
+
+  const createReferenceFoundInJsModule = async ({
     jsUrl,
     jsLine,
     jsColumn,
@@ -147,12 +153,6 @@ export const createRessourceBuilder = (
 
   const ressourceMap = {}
   const ressourceRedirectionMap = {}
-  // ok il faudrait faire un truc dans ce genre:
-  // lorsqu'on a un preload, on fait une promesse
-  // pour le moment ou la ressource est référencé par un autre truc
-  // ensuite dans le callback lorsque le build rollup est fini
-  // la on considere que ça n'a jamais été référencé, on resoud la promesse
-  // malgré tout
   const createReference = ({
     referenceShouldNotEmitChunk,
     isRessourceHint,
@@ -169,13 +169,29 @@ export const createRessourceBuilder = (
     isInline,
     fileNamePattern,
     urlVersioningDisabled,
+
+    fromRollup,
   }) => {
-    const importerUrl = referenceUrl
-    const ressourceImporter = ressourceFromUrl(importerUrl) || {
-      url: importerUrl,
-      isEntryPoint: false, // maybe
-      isJsModule: true,
-      bufferAfterBuild: "",
+    const existingRessourceForReference = ressourceFromUrl(referenceUrl)
+    let ressourceImporter
+    if (existingRessourceForReference) {
+      ressourceImporter = existingRessourceForReference
+    } else {
+      const referenceOriginalUrl = asOriginalServerUrl(referenceUrl)
+      if (referenceOriginalUrl) {
+        ressourceImporter = ressourceFromUrl(referenceOriginalUrl)
+      }
+      if (!ressourceImporter) {
+        // happens only for entry points?
+        // in that case the importer is theoric
+        // see "getCallerLocation()" in createReferenceForEntryPoint
+        ressourceImporter = {
+          url: referenceUrl,
+          isEntryPoint: false,
+          isJsModule: true,
+          bufferAfterBuild: "",
+        }
+      }
     }
 
     const shouldBeIgnoredWarning = referenceShouldBeIgnoredWarning({
@@ -240,26 +256,6 @@ export const createRessourceBuilder = (
       }
     }
 
-    const reference = {
-      referenceShouldNotEmitChunk,
-      isRessourceHint,
-      ressourceContentTypeExpected,
-      referenceUrl,
-      referenceColumn,
-      referenceLine,
-
-      isInline,
-      inlinedCallback: () => {
-        reference.isInline = true
-        const allReferenceAreInline = ressource.references.every(
-          (reference) => reference.isInline,
-        )
-        if (allReferenceAreInline) {
-          ressource.isInline = true
-        }
-      },
-    }
-
     const existingRessource = ressourceFromUrl(ressourceUrl)
     let ressource
     if (existingRessource) {
@@ -267,7 +263,7 @@ export const createRessourceBuilder = (
       // allow to update the bufferBeforeBuild on existingRessource
       // this happens when rollup loads a js file and communicates to this code
       // what was loaded
-      if (typeof bufferBeforeBuild !== "undefined") {
+      if (fromRollup) {
         ressource.bufferBeforeBuild = bufferBeforeBuild
         ressource.contentType = contentType
       }
@@ -286,8 +282,37 @@ export const createRessourceBuilder = (
       })
       ressourceMap[ressourceUrl] = ressource
     }
+
+    const reference = {
+      referenceShouldNotEmitChunk,
+      isRessourceHint,
+      ressourceContentTypeExpected,
+      referenceUrl,
+      referenceColumn,
+      referenceLine,
+
+      isInline,
+      inlinedCallback: () => {
+        reference.isInline = true
+        const allStrongReferenceAreInline = ressource.references.every(
+          (reference) => reference.isRessourceHint || reference.isInline,
+        )
+        if (allStrongReferenceAreInline) {
+          ressource.isInline = true
+          ressource.inlinedCallbacks.forEach((callback) => callback())
+        }
+      },
+    }
+
     reference.ressource = ressource
-    ressource.addReference(reference, { isJsModule })
+    if (fromRollup && ressourceImporter.isEntryPoint) {
+      // do not add that reference, it's already know and would duplicate the html referencing a js file
+      // but do apply its effects
+      ressource.applyReferenceEffects(reference, { isJsModule })
+    } else {
+      ressource.references.push(reference)
+      ressource.applyReferenceEffects(reference, { isJsModule })
+    }
 
     return reference
   }
@@ -329,6 +354,7 @@ export const createRessourceBuilder = (
     ressource.usedPromise = new Promise((resolve) => {
       ressource.usedCallback = resolve
     })
+    ressource.inlinedCallbacks = []
     ressource.buildDonePromise = new Promise((resolve, reject) => {
       ressource.buildDoneCallback = ({ buildFileInfo, buildManifest }) => {
         if (!ressource.isJsModule) {
@@ -735,9 +761,7 @@ export const createRessourceBuilder = (
       return effects
     }
 
-    const addReference = (reference, infoFromReference) => {
-      ressource.references.push(reference)
-
+    const applyReferenceEffects = (reference, infoFromReference) => {
       const referenceEffects = onReference(reference, infoFromReference)
 
       logger.debug(
@@ -750,7 +774,7 @@ export const createRessourceBuilder = (
     }
 
     Object.assign(ressource, {
-      addReference,
+      applyReferenceEffects,
       getBufferAvailablePromise,
       getDependenciesAvailablePromise,
       getReadyPromise,
@@ -761,7 +785,7 @@ export const createRessourceBuilder = (
     return ressource
   }
 
-  const buildEnd = ({ jsModuleBuild, buildManifest }) => {
+  const rollupBuildEnd = ({ jsModuleBuild, buildManifest }) => {
     Object.keys(ressourceMap).forEach((ressourceUrl) => {
       const ressource = ressourceMap[ressourceUrl]
       const { buildDoneCallback } = ressource
@@ -843,10 +867,10 @@ ${showSourceLocation(referenceSourceAsString, {
 
   return {
     createReferenceForEntryPoint,
-    createReferenceFoundInJs,
-    createReference,
+    createReferenceFoundByRollup,
+    createReferenceFoundInJsModule,
 
-    buildEnd,
+    rollupBuildEnd,
     getAllEntryPointsEmittedPromise,
     findRessource,
 

package/src/internal/building/transformImportMetaUrlReferences.js

@@ -29,7 +29,7 @@ export const transformImportMetaUrlReferences = async ({
       const response = await fetch(ressourceUrl, url)
       const bufferBeforeBuild = Buffer.from(await response.arrayBuffer())
 
-      const reference = await ressourceBuilder.createReferenceFoundInJs({
+      const reference = await ressourceBuilder.createReferenceFoundInJsModule({
         jsUrl: url,
         ...(node.loc
           ? {

package/src/internal/compiling/compile-directory/fs-optimized-for-cache.js

@@ -52,6 +52,6 @@ export const writeFileContent = async (
   }
 }
 
-export const testFilePresence = async (url) => {
+export const testFilePresence = (url) => {
   return existsSync(urlToFileSystemPath(url))
 }

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

@@ -88,6 +88,7 @@ export const getOrGenerateCompiledFile = async ({
             compileResult,
             compileResultStatus,
             compiledFileUrl,
+            // originalFileUrl,
             cacheHitTracking,
           }),
         )
@@ -214,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}`,
@@ -247,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 {
@@ -269,7 +273,7 @@ const getArgumentsForCompile = async ({
   } else {
     fileContent = await readFileContent(originalFileUrl)
   }
-  return [fileContent]
+  return fileContent
 }
 
 const startAsap = async (fn, { logger, compiledFileUrl }) => {