@jsenv/core 24.6.4 → 25.0.0-alpha.2

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

@@ -0,0 +1,23 @@
+import { readFileSync } from "node:fs"
+
+import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/internal/jsenvCoreDirectoryUrl.js"
+
+export const babelPluginSystemJsPrepend = (api) => {
+  api.assertVersion(7)
+  const systemJsUrl = new URL(
+    "src/internal/runtime/s.js",
+    jsenvCoreDirectoryUrl,
+  )
+  return {
+    name: "systemjs-prepend",
+    visitor: {
+      Program: {
+        exit(path) {
+          const code = String(readFileSync(systemJsUrl))
+          const ast = api.template.ast`${code}`
+          path.node.body.unshift(ast)
+        },
+      },
+    },
+  }
+}

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

@@ -11,6 +11,7 @@ import { babelPluginImportMetadata } from "@jsenv/core/src/internal/compiling/ba
 import { ansiToHTML } from "./ansiToHTML.js"
 import { babelPluginRegeneratorRuntimeAsJsenvImport } from "./babel_plugin_regenerator_runtime_as_jsenv_import.js"
 import { babelPluginBabelHelpersAsJsenvImports } from "./babel_plugin_babel_helpers_as_jsenv_imports.js"
+import { babelPluginSystemJsPrepend } from "./babel_plugin_systemjs_prepend.js"
 import { filePathToBabelHelperName } from "./babelHelper.js"
 
 export const jsenvTransform = async ({
@@ -26,6 +27,7 @@ export const jsenvTransform = async ({
   topLevelAwait,
 
   babelHelpersInjectionAsImport,
+  prependSystemJs,
   transformGenerator,
   regeneratorRuntimeImportPath,
   sourcemapEnabled,
@@ -77,7 +79,6 @@ export const jsenvTransform = async ({
       ],
     }
   }
-
   babelPluginMap = {
     ...getMinimalBabelPluginMap(),
     "transform-import-meta": [
@@ -147,6 +148,19 @@ export const jsenvTransform = async ({
       : {}),
     "import-metadata": [babelPluginImportMetadata],
   }
+  if (moduleOutFormat === "systemjs") {
+    babelPluginMap = {
+      ...babelPluginMap,
+      "proposal-dynamic-import": [proposalDynamicImport],
+      "transform-modules-systemjs": [transformModulesSystemJs],
+    }
+  }
+  if (prependSystemJs) {
+    babelPluginMap = {
+      ...babelPluginMap,
+      "systemjs-prepend": [babelPluginSystemJsPrepend],
+    }
+  }
 
   const asyncToPromise = babelPluginMap["transform-async-to-promises"]
   if (topLevelAwait && asyncToPromise) {
@@ -158,17 +172,7 @@ export const jsenvTransform = async ({
     code,
     options: {
       ...options,
-      plugins: babelPluginsFromBabelPluginMap({
-        ...babelPluginMap,
-        ...(moduleOutFormat === "systemjs"
-          ? {
-              "proposal-dynamic-import": [proposalDynamicImport],
-              ...(moduleOutFormat === "systemjs"
-                ? { "transform-modules-systemjs": [transformModulesSystemJs] }
-                : {}),
-            }
-          : {}),
-      }),
+      plugins: babelPluginsFromBabelPluginMap(babelPluginMap),
     },
   })
   code = babelTransformReturnValue.code

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

@@ -12,6 +12,7 @@ export const transformJs = async ({
   moduleOutFormat = "esmodule",
   importMetaFormat = moduleOutFormat,
   babelHelpersInjectionAsImport = moduleOutFormat === "esmodule",
+  prependSystemJs,
   topLevelAwait,
   transformGenerator = true,
   sourcemapEnabled = true,
@@ -51,6 +52,7 @@ export const transformJs = async ({
     importMetaFormat,
 
     babelHelpersInjectionAsImport,
+    prependSystemJs,
     topLevelAwait,
     transformGenerator,
     sourcemapEnabled,

package/src/internal/compiling/jsenvCompilerForHtml.js

@@ -8,7 +8,7 @@ import {
   TOOLBAR_INJECTOR_BUILD_URL,
 } from "@jsenv/core/dist/build_manifest.js"
 import { fetchUrl } from "@jsenv/core/src/internal/fetchUrl.js"
-import { getDefaultImportMap } from "@jsenv/core/src/internal/import-resolution/importmap-default.js"
+import { getDefaultImportmap } from "@jsenv/core/src/internal/import-resolution/importmap_default.js"
 
 import {
   setJavaScriptSourceMappingUrl,
@@ -120,83 +120,82 @@ export const compileHtml = async ({
           importmapInfo = {
             script,
             url: resolveUrl(src, url),
-            loadAsText: async () => {
+            load: async () => {
               const importMapResponse = await fetchUrl(importmapInfo.url)
-              if (importMapResponse.status !== 200) {
-                logger.warn(
-                  createDetailedMessage(
-                    importMapResponse.status === 404
-                      ? `importmap script file cannot be found.`
-                      : `importmap script file unexpected response status (${importMapResponse.status}).`,
-                    {
-                      "importmap url": importmapInfo.url,
-                      "html url": url,
-                    },
-                  ),
+              if (importMapResponse.status === 200) {
+                const importmapAsText = await importMapResponse.text()
+                let htmlImportmap = JSON.parse(importmapAsText)
+                htmlImportmap = moveImportMap(
+                  htmlImportmap,
+                  importmapInfo.url,
+                  url,
                 )
-                return "{}"
+                sources.push(importmapInfo.url)
+                sourcesContent.push(importmapAsText)
+                return htmlImportmap
               }
-              const importmapAsText = await importMapResponse.text()
-              sources.push(importmapInfo.url)
-              sourcesContent.push(importmapAsText)
-
-              const importMapMoved = moveImportMap(
-                JSON.parse(importmapAsText),
-                importmapInfo.url,
-                url,
-              )
-              const compiledImportmapAsText = JSON.stringify(
-                importMapMoved,
-                null,
-                "  ",
+              logger.warn(
+                createDetailedMessage(
+                  importMapResponse.status === 404
+                    ? `importmap script file cannot be found.`
+                    : `importmap script file unexpected response status (${importMapResponse.status}).`,
+                  {
+                    "importmap url": importmapInfo.url,
+                    "html url": url,
+                  },
+                ),
               )
-              return compiledImportmapAsText
+              return {}
             },
           }
         } else {
           importmapInfo = {
             script,
             url: compiledUrl,
-            loadAsText: () => getHtmlNodeTextNode(script).value,
+            load: () => {
+              const jsenvImportmap = getDefaultImportmap(compiledUrl, {
+                projectDirectoryUrl,
+                compileDirectoryUrl: `${projectDirectoryUrl}${compileId}/${outDirectoryRelativeUrl}`,
+              })
+              const htmlImportmap = JSON.parse(
+                getHtmlNodeTextNode(script).value,
+              )
+              const importmap = composeTwoImportMaps(
+                jsenvImportmap,
+                htmlImportmap,
+              )
+              return importmap
+            },
           }
         }
       }
     }
   })
   if (importmapInfo) {
-    const htmlImportMap = JSON.parse(await importmapInfo.loadAsText())
-    const importMapFromJsenv = getDefaultImportMap({
-      importMapFileUrl: compiledUrl,
-      projectDirectoryUrl,
-      compileDirectoryRelativeUrl: `${outDirectoryRelativeUrl}${compileId}/`,
-    })
-    const mappings = composeTwoImportMaps(importMapFromJsenv, htmlImportMap)
-    const importmapAsText = JSON.stringify(mappings, null, "  ")
+    const importmap = await importmapInfo.load()
+    const importmapAsText = JSON.stringify(importmap, null, "  ")
     replaceHtmlNode(
       importmapInfo.script,
       `<script type="${
-        moduleOutFormat === "systemjs" ? "jsenv-importmap" : "importmap"
+        moduleOutFormat === "systemjs" ? "systemjs-importmap" : "importmap"
       }">${importmapAsText}</script>`,
       {
         attributesToIgnore: ["src"],
       },
     )
     importmapInfo.inlinedFrom = importmapInfo.url
-    importmapInfo.url = compiledUrl
     importmapInfo.text = importmapAsText
   } else {
-    // inject a default importmap
-    const defaultImportMap = getDefaultImportMap({
-      importMapFileUrl: compiledUrl,
+    const defaultImportMap = getDefaultImportmap(compiledUrl, {
       projectDirectoryUrl,
-      compileDirectoryRelativeUrl: `${outDirectoryRelativeUrl}${compileId}/`,
+      compileDirectoryUrl: `${projectDirectoryUrl}${outDirectoryRelativeUrl}${compileId}/`,
     })
     const importmapAsText = JSON.stringify(defaultImportMap, null, "  ")
     manipulateHtmlAst(htmlAst, {
       scriptInjections: [
         {
           type:
-            moduleOutFormat === "systemjs" ? "jsenv-importmap" : "importmap",
+            moduleOutFormat === "systemjs" ? "systemjs-importmap" : "importmap",
           // in case there is no importmap, force the presence
           // so that '@jsenv/core/' are still remapped
           text: importmapAsText,

package/src/internal/compiling/jsenvCompilerForImportmap.js

@@ -1,89 +1,28 @@
-/**
- * allows the following:
- *
- * import "@jsenv/core/helpers/regenerator-runtime/regenerator-runtime.js"
- * -> searches a file inside @jsenv/core/*
- *
- */
-
-import { urlToRelativeUrl, urlIsInsideOf } from "@jsenv/filesystem"
 import { composeTwoImportMaps } from "@jsenv/importmap"
 
-import { jsenvCoreDirectoryUrl } from "../jsenvCoreDirectoryUrl.js"
-
-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),
-    {},
-  )
+import { getDefaultImportmap } from "@jsenv/core/src/internal/import-resolution/importmap_default.js"
 
-  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]
-      }
-    })
+export const compileImportmap = async ({
+  code,
+  url,
+  compiledUrl,
+  projectDirectoryUrl,
+  outDirectoryRelativeUrl,
+  compileId,
+}) => {
+  const jsenvImportmap = getDefaultImportmap(compiledUrl, {
+    projectDirectoryUrl,
+    compileDirectoryUrl: `${projectDirectoryUrl}${outDirectoryRelativeUrl}${compileId}/`,
   })
+  const projectImportmap = JSON.parse(code)
+  const importmap = composeTwoImportMaps(jsenvImportmap, projectImportmap)
 
   return {
     contentType: "application/importmap+json",
-    compiledSource: JSON.stringify(importMap, null, "  "),
+    compiledSource: JSON.stringify(importmap, null, "  "),
     sources: [url],
     sourcesContent: [code],
     assets: [],
     assetsContent: [],
   }
 }
-
-// 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

@@ -9,13 +9,21 @@ export const compileJavascript = async ({
   projectDirectoryUrl,
 
   babelPluginMap,
+  workerUrls,
+  serviceWorkerUrls,
   moduleOutFormat,
   importMetaFormat,
   topLevelAwait,
+  prependSystemJs,
 
   sourcemapExcludeSources,
   sourcemapMethod,
 }) => {
+  if (prependSystemJs === undefined) {
+    prependSystemJs =
+      workerUrls.includes(url) || serviceWorkerUrls.includes(url)
+  }
+
   const transformResult = await transformJs({
     code,
     map,
@@ -27,6 +35,7 @@ export const compileJavascript = async ({
     moduleOutFormat,
     importMetaFormat,
     topLevelAwait,
+    prependSystemJs,
   })
 
   return transformResultToCompilationResult(

package/src/internal/compiling/startCompileServer.js

@@ -95,10 +95,13 @@ export const startCompileServer = async ({
   babelPluginMap,
   babelConfigFileUrl,
   customCompilers = {},
-
-  // remaining options
+  workers = [],
+  serviceWorkers = [],
+  importMapInWebWorkers = false,
+  prependSystemJs,
   runtimeSupport,
 
+  // remaining options
   livereloadWatchConfig = {
     "./**": true,
     "./**/.*/": false, // any folder starting with a dot is ignored (includes .git for instance)
@@ -138,9 +141,14 @@ export const startCompileServer = async ({
     jsenvDirectoryUrl,
     projectDirectoryUrl,
   )
-
   const logger = createLogger({ logLevel })
 
+  const workerUrls = workers.map((worker) =>
+    resolveUrl(worker, projectDirectoryUrl),
+  )
+  const serviceWorkerUrls = serviceWorkers.map((serviceWorker) =>
+    resolveUrl(serviceWorker, projectDirectoryUrl),
+  )
   const browser = isBrowserPartOfSupportedRuntimes(runtimeSupport)
   const babelPluginMapFromFile = await loadBabelPluginMapFromFile({
     projectDirectoryUrl,
@@ -177,7 +185,19 @@ export const startCompileServer = async ({
   const { babelSyntaxPluginMap, babelPluginMapWithoutSyntax } =
     extractSyntaxBabelPluginMap(babelPluginMap)
   const compileServerGroupMap = generateGroupMap({
-    babelPluginMap: babelPluginMapWithoutSyntax,
+    featureNames: [
+      ...(browser
+        ? [
+            "module",
+            "importmap",
+            "import_assertion_type_json",
+            "import_assertion_type_css",
+          ]
+        : []),
+      ...(browser && workerUrls.length > 0 ? ["worker_type_module"] : []),
+      ...(browser && importMapInWebWorkers ? ["worker_importmap"] : []),
+      ...Object.keys(babelPluginMapWithoutSyntax),
+    ],
     runtimeSupport,
   })
 
@@ -188,7 +208,7 @@ export const startCompileServer = async ({
     // It happens for module written in ESM but also using process.env.NODE_ENV
     // for example "react-redux"
     // This babel plugin won't force compilation because it's added after "generateGroupMap"
-    // however it will be used even if not part of "pluginRequiredNameArray"
+    // however it will be used even if not part of "missingFeatureNames"
     // as visible in "babelPluginMapFromCompileId"
     // This is a quick workaround to get things working because:
     // - If none of your code needs to be compiled but one of your dependency
@@ -314,6 +334,10 @@ export const startCompileServer = async ({
       groupMap: compileServerGroupMap,
       babelPluginMap,
       customCompilers,
+      workerUrls,
+      serviceWorkerUrls,
+      importMapInWebWorkers,
+      prependSystemJs,
       moduleOutFormat,
       importMetaFormat,
       jsenvEventSourceClientInjection,

package/src/internal/dev_server/event_source_client/livereload_preference.js

@@ -1,7 +1,7 @@
 /* eslint-env browser */
 
 export const isLivereloadEnabled = () => {
-  const value = window.localStorage.hasOwnProperty("livereload")
+  const value = window.localStorage.getItem("livereload")
   if (value === "0") {
     return false
   }

package/src/internal/dev_server/toolbar/compilation/toolbar.compilation.js

@@ -14,7 +14,7 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
       canAvoidCompilation,
       featuresReport,
       customCompilerPatterns,
-      pluginRequiredNameArray,
+      missingFeatureNames,
       inlineImportMapIntoHTML,
       outDirectoryRelativeUrl,
       compileId,
@@ -38,7 +38,7 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
                 missingOnly: true,
                 featuresReport,
                 customCompilerPatterns,
-                pluginRequiredNameArray,
+                missingFeatureNames,
                 inlineImportMapIntoHTML,
               },
             )}`,
@@ -54,7 +54,7 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
               {
                 featuresReport,
                 customCompilerPatterns,
-                pluginRequiredNameArray,
+                missingFeatureNames,
                 inlineImportMapIntoHTML,
               },
             )}`,
@@ -70,7 +70,7 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
               {
                 featuresReport,
                 customCompilerPatterns,
-                pluginRequiredNameArray,
+                missingFeatureNames,
                 inlineImportMapIntoHTML,
               },
             )}`,
@@ -128,7 +128,7 @@ const getBrowserSupportMessage = ({
   missingOnly,
   featuresReport,
   customCompilerPatterns,
-  pluginRequiredNameArray,
+  missingFeatureNames,
   inlineImportMapIntoHTML,
 }) => {
   const parts = []
@@ -161,14 +161,14 @@ const getBrowserSupportMessage = ({
     parts.push(`top level await is not supported`)
   }
 
-  const pluginRequiredCount = pluginRequiredNameArray.length
-  if (pluginRequiredCount === 0) {
+  const missingFeatureCount = missingFeatureNames.length
+  if (missingFeatureCount === 0) {
     if (!missingOnly) {
-      parts.push(`all plugins are natively supported`)
+      parts.push(`all features are natively supported`)
     }
   } else {
     parts.push(
-      `${pluginRequiredCount} plugins are mandatory: ${pluginRequiredNameArray}`,
+      `${missingFeatureCount} features are missing: ${missingFeatureNames}`,
     )
   }
 

package/src/internal/executing/executePlan.js

@@ -51,6 +51,9 @@ export const executePlan = async (
     compileServerCanWriteOnFilesystem,
     babelPluginMap,
     babelConfigFileUrl,
+    workers,
+    serviceWorkers,
+    importMapInWebWorkers,
     customCompilers,
   } = {},
 ) => {
@@ -123,6 +126,9 @@ export const executePlan = async (
       keepProcessAlive: true, // to be sure it stays alive
       babelPluginMap,
       babelConfigFileUrl,
+      workers,
+      serviceWorkers,
+      importMapInWebWorkers,
       customCompilers,
       runtimeSupport,
     })

package/src/internal/generateGroupMap/{featuresCompatMap.js → features_compatibility.js}

@@ -1,4 +1,4 @@
-// https://github.com/babel/babel/blob/master/packages/babel-compat-data/data/native-modules.json#L1
+import { jsenvBabelPluginCompatMap } from "./babel_plugins_compatibility.js"
 
 export const featuresCompatMap = {
   module: {
@@ -26,4 +26,12 @@ export const featuresCompatMap = {
     chrome: "93",
     edge: "93",
   },
+  worker_type_module: {
+    chrome: "80",
+    edge: "80",
+    opera: "67",
+    android: "80",
+  },
+  worker_importmap: {},
+  ...jsenvBabelPluginCompatMap,
 }

package/src/internal/generateGroupMap/generateGroupMap.js

@@ -17,7 +17,7 @@
 
 {
   "best": {
-    "pluginRequiredNameArray" : [
+    "missingFeatureNames" : [
       "transform-block-scoping",
     ],
     "minRuntimeVersions": {
@@ -33,40 +33,20 @@ Take chars below to update legends
 */
 
 import { COMPILE_ID_OTHERWISE, COMPILE_ID_BEST } from "../CONSTANTS.js"
-import { jsenvBabelPluginCompatMap } from "./jsenvBabelPluginCompatMap.js"
-import { jsenvPluginCompatMap } from "./jsenvPluginCompatMap.js"
 import { createRuntimeCompat } from "./runtime_compat.js"
 
-export const generateGroupMap = ({
-  babelPluginMap,
-  runtimeSupport,
-  babelPluginCompatMap = jsenvBabelPluginCompatMap,
-  // jsenv plugin are for later, for now, nothing is using them
-  jsenvPluginMap = {},
-}) => {
-  if (typeof babelPluginMap !== "object") {
-    throw new TypeError(
-      `babelPluginMap must be an object, got ${babelPluginMap}`,
-    )
-  }
-  if (typeof jsenvPluginMap !== "object") {
-    throw new TypeError(
-      `jsenvPluginMap must be an object, got ${jsenvPluginMap}`,
-    )
+export const generateGroupMap = ({ featureNames, runtimeSupport }) => {
+  if (!Array.isArray(featureNames)) {
+    throw new TypeError(`featureNames must be an array, got ${featureNames}`)
   }
   if (typeof runtimeSupport !== "object") {
     throw new TypeError(
       `runtimeSupport must be an object, got ${runtimeSupport}`,
     )
   }
-
   const runtimeNames = Object.keys(runtimeSupport)
-
   const groupWithoutFeature = {
-    pluginRequiredNameArray: [
-      ...Object.keys(babelPluginMap),
-      ...Object.keys(jsenvPluginMap),
-    ],
+    missingFeatureNames: featureNames,
     minRuntimeVersions: {},
   }
   if (runtimeNames.length === 0) {
@@ -74,19 +54,10 @@ export const generateGroupMap = ({
       [COMPILE_ID_OTHERWISE]: groupWithoutFeature,
     }
   }
-
   const runtimeCompat = createRuntimeCompat({
     runtimeSupport,
-    pluginMap: {
-      ...babelPluginMap,
-      ...jsenvPluginMap,
-    },
-    pluginCompatMap: {
-      ...babelPluginCompatMap,
-      ...jsenvPluginCompatMap,
-    },
+    featureNames,
   })
-
   return {
     [COMPILE_ID_BEST]: runtimeCompat,
     [COMPILE_ID_OTHERWISE]: groupWithoutFeature,

package/src/internal/generateGroupMap/one_runtime_compat.js

@@ -3,18 +3,16 @@ import { findHighestVersion } from "../semantic_versioning/index.js"
 export const createOneRuntimeCompat = ({
   runtimeName,
   runtimeVersion,
-
-  pluginMap,
-  pluginCompatMap,
+  featureNames,
+  featuresCompatMap,
 }) => {
-  const pluginRequiredNameArray = []
+  const missingFeatureNames = []
   // will be the first runtime version compatible with all features not listed in
-  // pluginRequiredNameArray
+  // missingFeatureNames
   let minRuntimeVersion
-
-  Object.keys(pluginMap).forEach((pluginName) => {
-    const pluginCompat = pluginCompatMap[pluginName] || {}
-    const runtimeVersionCompatible = pluginCompat[runtimeName] || "Infinity"
+  featureNames.forEach((featureName) => {
+    const featureCompat = featuresCompatMap[featureName] || {}
+    const runtimeVersionCompatible = featureCompat[runtimeName] || "Infinity"
 
     const highestVersion = findHighestVersion(
       runtimeVersion,
@@ -22,7 +20,7 @@ export const createOneRuntimeCompat = ({
     )
     const compatible = highestVersion === runtimeVersion
     if (!compatible) {
-      pluginRequiredNameArray.push(pluginName)
+      missingFeatureNames.push(featureName)
     }
 
     if (compatible && runtimeVersionCompatible !== "Infinity") {
@@ -33,9 +31,8 @@ export const createOneRuntimeCompat = ({
       )
     }
   })
-
   return {
-    pluginRequiredNameArray,
+    missingFeatureNames,
     minRuntimeVersion: minRuntimeVersion || runtimeVersion,
   }
 }