@jsenv/core 27.0.0-alpha.64 → 27.0.0-alpha.65

package/src/dev/start_dev_server.js

@@ -14,7 +14,7 @@ import { createKitchen } from "@jsenv/core/src/omega/kitchen.js"
 import { startOmegaServer } from "@jsenv/core/src/omega/omega_server.js"
 
 import { jsenvPluginExplorer } from "./plugins/explorer/jsenv_plugin_explorer.js"
-import { jsenvPluginToolbar } from "./plugins/toolbar/jsenv_plugin_toolbar.js"
+// import { jsenvPluginToolbar } from "./plugins/toolbar/jsenv_plugin_toolbar.js"
 
 export const startDevServer = async ({
   signal = new AbortController().signal,
@@ -53,7 +53,18 @@ export const startDevServer = async ({
   clientAutoreload = true,
 
   sourcemaps = "inline",
+  // default runtimeCompat assume dev server will be request by recent browsers
+  // Used by "jsenv_plugin_node_runtime.js" to deactivate itself
+  // If dev server can be requested by Node.js to exec files
+  // we would add "node" to the potential runtimes. For now it's out of the scope of the dev server
+  // and "jsenv_plugin_node_runtime.js" applies only during build made for node.js
+  runtimeCompat = {
+    chrome: "100",
+    firefox: "100",
+    safari: "15.5",
+  },
   plugins = [],
+  urlAnalysis = {},
   htmlSupervisor = true,
   injectedGlobals,
   nodeEsmResolution,
@@ -68,7 +79,7 @@ export const startDevServer = async ({
       "./test/**/*.test.html": true,
     },
   },
-  toolbar = false,
+  // toolbar = false,
   writeGeneratedFiles = true,
 }) => {
   const logger = createLogger({ logLevel })
@@ -164,6 +175,7 @@ export const startDevServer = async ({
     rootDirectoryUrl,
     urlGraph,
     scenario: "dev",
+    runtimeCompat,
     sourcemaps,
     writeGeneratedFiles,
     plugins: [
@@ -172,7 +184,9 @@ export const startDevServer = async ({
         rootDirectoryUrl,
         urlGraph,
         scenario: "dev",
+        runtimeCompat,
 
+        urlAnalysis,
         htmlSupervisor,
         injectedGlobals,
         nodeEsmResolution,
@@ -185,7 +199,7 @@ export const startDevServer = async ({
       jsenvPluginExplorer({
         groups: explorerGroups,
       }),
-      ...(toolbar ? [jsenvPluginToolbar(toolbar)] : []),
+      // ...(toolbar ? [jsenvPluginToolbar(toolbar)] : []),
     ],
   })
   const server = await startOmegaServer({

package/src/execute/execute.js

@@ -68,6 +68,7 @@ export const execute = async ({
   }
   if (runtime.needsServer) {
     const urlGraph = createUrlGraph()
+    const runtimeCompat = { [runtime.name]: runtime.version }
     const kitchen = createKitchen({
       signal,
       logger,
@@ -75,6 +76,7 @@ export const execute = async ({
       urlGraph,
       scenario,
       sourcemaps,
+      runtimeCompat,
       writeGeneratedFiles,
       plugins: [
         ...plugins,
@@ -82,6 +84,7 @@ export const execute = async ({
           rootDirectoryUrl,
           urlGraph,
           scenario,
+          runtimeCompat,
 
           htmlSupervisor,
           injectedGlobals,

package/src/omega/errors.js

@@ -97,13 +97,16 @@ export const createTransformUrlContentError = ({
     ...details
   }) => {
     const transformError = new Error(
-      createDetailedMessage(`Failed to transform ${urlInfo.type} url content`, {
-        reason,
-        ...details,
-        "url": urlInfo.url,
-        "url reference trace": reference.trace,
-        ...detailsFromPluginController(pluginController),
-      }),
+      createDetailedMessage(
+        `Failed to transform url content of "${urlInfo.type}"`,
+        {
+          reason,
+          ...details,
+          "url": urlInfo.url,
+          "url reference trace": reference.trace,
+          ...detailsFromPluginController(pluginController),
+        },
+      ),
     )
     transformError.name = "TRANSFORM_URL_CONTENT_ERROR"
     transformError.code = code

package/src/omega/kitchen.js

@@ -15,7 +15,6 @@ import { createPluginController } from "../plugins/plugin_controller.js"
 import { urlSpecifierEncoding } from "./url_specifier_encoding.js"
 import { createUrlInfoTransformer } from "./url_graph/url_info_transformations.js"
 import { RUNTIME_COMPAT } from "./compat/runtime_compat.js"
-import { defaultRuntimeCompat } from "./compat/default_runtime_compat.js"
 import {
   createResolveUrlError,
   createFetchUrlContentError,
@@ -46,7 +45,7 @@ export const createKitchen = ({
     build: true,
   }[scenario],
   sourcemapsRelativeSources,
-  runtimeCompat = defaultRuntimeCompat,
+  runtimeCompat,
   writeGeneratedFiles,
 }) => {
   const pluginController = createPluginController({
@@ -86,7 +85,7 @@ export const createKitchen = ({
     specifierColumn,
     baseUrl,
     isOriginalPosition,
-    external = false,
+    shouldHandle,
     isInline = false,
     injected = false,
     isRessourceHint = false,
@@ -122,7 +121,7 @@ export const createKitchen = ({
       specifierColumn,
       baseUrl,
       isOriginalPosition,
-      external,
+      shouldHandle,
       isInline,
       injected,
       isRessourceHint,
@@ -152,11 +151,6 @@ export const createKitchen = ({
       }
       resolvedUrl = normalizeUrl(resolvedUrl)
       reference.url = resolvedUrl
-      if (reference.external) {
-        reference.generatedUrl = resolvedUrl
-        reference.generatedSpecifier = reference.specifier
-        return urlGraph.reuseOrCreateUrlInfo(reference.url)
-      }
       pluginController.callHooks(
         "redirectUrl",
         reference,
@@ -259,10 +253,6 @@ export const createKitchen = ({
   })
 
   const fetchUrlContent = async (urlInfo, { reference, context }) => {
-    if (reference.external) {
-      urlInfo.external = true
-      return
-    }
     try {
       const fetchUrlContentReturnValue =
         await pluginController.callAsyncHooksUntil(
@@ -273,18 +263,13 @@ export const createKitchen = ({
       if (!fetchUrlContentReturnValue) {
         logger.warn(
           createDetailedMessage(
-            `no plugin has handled the url during "fetchUrlContent" hook -> consider url as external (ignore it)`,
+            `no plugin has handled url during "fetchUrlContent" hook -> url will be ignored`,
             {
               "url": urlInfo.url,
               "url reference trace": reference.trace,
             },
           ),
         )
-        urlInfo.external = true
-        return
-      }
-      if (fetchUrlContentReturnValue.external) {
-        urlInfo.external = true
         return
       }
       const {
@@ -367,206 +352,207 @@ export const createKitchen = ({
       return fetchUrlContent(urlInfo, { reference, context })
     }
 
-    // "fetchUrlContent" hook
-    await fetchUrlContent(urlInfo, { reference: context.reference, context })
-    if (urlInfo.external) {
-      return
-    }
+    if (urlInfo.shouldHandle) {
+      // "fetchUrlContent" hook
+      await fetchUrlContent(urlInfo, { reference: context.reference, context })
 
-    // parsing
-    const references = []
-    const addReference = (props) => {
-      const reference = createReference({
-        parentUrl: urlInfo.url,
-        ...props,
-      })
-      references.push(reference)
-      const referencedUrlInfo = resolveReference(reference)
-      return [reference, referencedUrlInfo]
-    }
-    const referenceUtils = {
-      readGeneratedSpecifier: async (reference) => {
-        // "formatReferencedUrl" can be async BUT this is an exception
-        // for most cases it will be sync. We want to favor the sync signature to keep things simpler
-        // The only case where it needs to be async is when
-        // the specifier is a `data:*` url
-        // in this case we'll wait for the promise returned by
-        // "formatReferencedUrl"
-        if (reference.generatedSpecifier.then) {
-          return reference.generatedSpecifier.then((value) => {
-            reference.generatedSpecifier = value
-            return value
-          })
-        }
-        return reference.generatedSpecifier
-      },
-      found: ({ specifierLine, specifierColumn, ...rest }) => {
-        const trace = stringifyUrlSite(
-          adjustUrlSite(urlInfo, {
-            urlGraph,
-            url: urlInfo.url,
-            line: specifierLine,
-            column: specifierColumn,
-          }),
-        )
-        // console.log(trace)
-        return addReference({
-          trace,
-          specifierLine,
-          specifierColumn,
-          ...rest,
-        })
-      },
-      foundInline: ({ isOriginalPosition, line, column, ...rest }) => {
-        const parentUrl = isOriginalPosition
-          ? urlInfo.url
-          : urlInfo.generatedUrl
-        const parentContent = isOriginalPosition
-          ? urlInfo.originalContent
-          : urlInfo.content
-        return addReference({
-          trace: stringifyUrlSite({
-            url: parentUrl,
-            content: parentContent,
-            line,
-            column,
-          }),
-          isOriginalPosition,
-          line,
-          column,
-          isInline: true,
-          ...rest,
+      // parsing
+      const references = []
+      const addReference = (props) => {
+        const reference = createReference({
+          parentUrl: urlInfo.url,
+          ...props,
         })
-      },
-      update: (currentReference, newReferenceParams) => {
-        const index = references.indexOf(currentReference)
-        if (index === -1) {
-          throw new Error(`reference do not exists`)
-        }
-        const previousReference = currentReference
-        const nextReference = createReference({
-          ...previousReference,
-          ...newReferenceParams,
-        })
-        references[index] = nextReference
-        mutateReference(previousReference, nextReference)
-        const newUrlInfo = resolveReference(nextReference)
-        const currentUrlInfo = context.urlGraph.getUrlInfo(currentReference.url)
-        if (
-          currentUrlInfo &&
-          currentUrlInfo !== newUrlInfo &&
-          currentUrlInfo.dependents.size === 0
-        ) {
-          context.urlGraph.deleteUrlInfo(currentReference.url)
-        }
-        return [nextReference, newUrlInfo]
-      },
-      becomesInline: (
-        reference,
-        {
-          isOriginalPosition,
-          specifier,
-          specifierLine,
-          specifierColumn,
-          contentType,
-          content,
+        references.push(reference)
+        const referencedUrlInfo = resolveReference(reference)
+        return [reference, referencedUrlInfo]
+      }
+      const referenceUtils = {
+        readGeneratedSpecifier: async (reference) => {
+          // "formatReferencedUrl" can be async BUT this is an exception
+          // for most cases it will be sync. We want to favor the sync signature to keep things simpler
+          // The only case where it needs to be async is when
+          // the specifier is a `data:*` url
+          // in this case we'll wait for the promise returned by
+          // "formatReferencedUrl"
+          if (reference.generatedSpecifier.then) {
+            return reference.generatedSpecifier.then((value) => {
+              reference.generatedSpecifier = value
+              return value
+            })
+          }
+          return reference.generatedSpecifier
         },
-      ) => {
-        const parentUrl = isOriginalPosition
-          ? urlInfo.url
-          : urlInfo.generatedUrl
-        const parentContent = isOriginalPosition
-          ? urlInfo.originalContent
-          : urlInfo.content
-        return referenceUtils.update(reference, {
-          trace: stringifyUrlSite({
-            url: parentUrl,
-            content: parentContent,
-            line: specifierLine,
-            column: specifierColumn,
-          }),
-          isOriginalPosition,
-          isInline: true,
-          specifier,
-          specifierLine,
-          specifierColumn,
-          contentType,
-          content,
-        })
-      },
-      inject: ({ trace, ...rest }) => {
-        if (trace === undefined) {
-          const { url, line, column } = getCallerPosition()
-          trace = stringifyUrlSite({
-            url,
+        found: ({ trace, ...rest }) => {
+          if (trace === undefined) {
+            trace = stringifyUrlSite(
+              adjustUrlSite(urlInfo, {
+                urlGraph,
+                url: urlInfo.url,
+                line: rest.specifierLine,
+                column: rest.specifierColumn,
+              }),
+            )
+          }
+          // console.log(trace)
+          return addReference({
+            trace,
+            ...rest,
+          })
+        },
+        foundInline: ({ isOriginalPosition, line, column, ...rest }) => {
+          const parentUrl = isOriginalPosition
+            ? urlInfo.url
+            : urlInfo.generatedUrl
+          const parentContent = isOriginalPosition
+            ? urlInfo.originalContent
+            : urlInfo.content
+          return addReference({
+            trace: stringifyUrlSite({
+              url: parentUrl,
+              content: parentContent,
+              line,
+              column,
+            }),
+            isOriginalPosition,
             line,
             column,
+            isInline: true,
+            ...rest,
           })
-        }
-        return addReference({
-          trace,
-          injected: true,
-          ...rest,
-        })
-      },
-      findByGeneratedSpecifier: (generatedSpecifier) => {
-        const reference = references.find(
-          (ref) => ref.generatedSpecifier === generatedSpecifier,
-        )
-        if (!reference) {
-          throw new Error(
-            `No reference found using the following generatedSpecifier: "${generatedSpecifier}"`,
+        },
+        update: (currentReference, newReferenceParams) => {
+          const index = references.indexOf(currentReference)
+          if (index === -1) {
+            throw new Error(`reference do not exists`)
+          }
+          const previousReference = currentReference
+          const nextReference = createReference({
+            ...previousReference,
+            ...newReferenceParams,
+          })
+          references[index] = nextReference
+          mutateReference(previousReference, nextReference)
+          const newUrlInfo = resolveReference(nextReference)
+          const currentUrlInfo = context.urlGraph.getUrlInfo(
+            currentReference.url,
           )
-        }
-        return reference
-      },
-    }
-
-    // "transform" hook
-    urlInfo.references = references
-    context.referenceUtils = referenceUtils
-    try {
-      await pluginController.callAsyncHooks(
-        "transformUrlContent",
-        urlInfo,
-        context,
-        async (transformReturnValue) => {
-          await urlInfoTransformer.applyIntermediateTransformations(
-            urlInfo,
-            transformReturnValue,
+          if (
+            currentUrlInfo &&
+            currentUrlInfo !== newUrlInfo &&
+            currentUrlInfo.dependents.size === 0
+          ) {
+            context.urlGraph.deleteUrlInfo(currentReference.url)
+          }
+          return [nextReference, newUrlInfo]
+        },
+        becomesInline: (
+          reference,
+          {
+            isOriginalPosition,
+            specifier,
+            specifierLine,
+            specifierColumn,
+            contentType,
+            content,
+          },
+        ) => {
+          const parentUrl = isOriginalPosition
+            ? urlInfo.url
+            : urlInfo.generatedUrl
+          const parentContent = isOriginalPosition
+            ? urlInfo.originalContent
+            : urlInfo.content
+          return referenceUtils.update(reference, {
+            trace: stringifyUrlSite({
+              url: parentUrl,
+              content: parentContent,
+              line: specifierLine,
+              column: specifierColumn,
+            }),
+            isOriginalPosition,
+            isInline: true,
+            specifier,
+            specifierLine,
+            specifierColumn,
+            contentType,
+            content,
+          })
+        },
+        inject: ({ trace, ...rest }) => {
+          if (trace === undefined) {
+            const { url, line, column } = getCallerPosition()
+            trace = stringifyUrlSite({
+              url,
+              line,
+              column,
+            })
+          }
+          return addReference({
+            trace,
+            injected: true,
+            ...rest,
+          })
+        },
+        findByGeneratedSpecifier: (generatedSpecifier) => {
+          const reference = references.find(
+            (ref) => ref.generatedSpecifier === generatedSpecifier,
           )
+          if (!reference) {
+            throw new Error(
+              `No reference found using the following generatedSpecifier: "${generatedSpecifier}"`,
+            )
+          }
+          return reference
         },
-      )
-    } catch (error) {
-      throw createTransformUrlContentError({
-        pluginController,
-        reference: context.reference,
-        urlInfo,
-        error,
-      })
-    }
-    // after "transform" all references from originalContent
-    // and the one injected by plugin are known
-    urlGraph.updateReferences(urlInfo, references)
+      }
 
-    // "finalize" hook
-    try {
-      const finalizeReturnValue = await pluginController.callAsyncHooksUntil(
-        "finalizeUrlContent",
-        urlInfo,
-        context,
-      )
-      await urlInfoTransformer.applyFinalTransformations(
-        urlInfo,
-        finalizeReturnValue,
-      )
-    } catch (error) {
-      throw createFinalizeUrlContentError({
-        pluginController,
-        reference: context.reference,
-        urlInfo,
-        error,
-      })
+      // "transform" hook
+      urlInfo.references = references
+      context.referenceUtils = referenceUtils
+      try {
+        await pluginController.callAsyncHooks(
+          "transformUrlContent",
+          urlInfo,
+          context,
+          async (transformReturnValue) => {
+            await urlInfoTransformer.applyIntermediateTransformations(
+              urlInfo,
+              transformReturnValue,
+            )
+          },
+        )
+      } catch (error) {
+        throw createTransformUrlContentError({
+          pluginController,
+          reference: context.reference,
+          urlInfo,
+          error,
+        })
+      }
+      // after "transform" all references from originalContent
+      // and the one injected by plugin are known
+      urlGraph.updateReferences(urlInfo, references)
+
+      // "finalize" hook
+      try {
+        const finalizeReturnValue = await pluginController.callAsyncHooksUntil(
+          "finalizeUrlContent",
+          urlInfo,
+          context,
+        )
+        await urlInfoTransformer.applyFinalTransformations(
+          urlInfo,
+          finalizeReturnValue,
+        )
+      } catch (error) {
+        throw createFinalizeUrlContentError({
+          pluginController,
+          reference: context.reference,
+          urlInfo,
+          error,
+        })
+      }
     }
 
     // "cooked" hook
@@ -602,13 +588,17 @@ export const createKitchen = ({
     } finally {
       const { generatedUrl } = urlInfo
       if (generatedUrl && generatedUrl.startsWith("file:")) {
-        writeFileSync(new URL(generatedUrl), urlInfo.content)
-        const { sourcemapGeneratedUrl, sourcemap } = urlInfo
-        if (sourcemapGeneratedUrl && sourcemap) {
-          writeFileSync(
-            new URL(sourcemapGeneratedUrl),
-            JSON.stringify(sourcemap, null, "  "),
-          )
+        if (urlInfo.type === "directory") {
+          // no need to write the directory
+        } else {
+          writeFileSync(new URL(generatedUrl), urlInfo.content)
+          const { sourcemapGeneratedUrl, sourcemap } = urlInfo
+          if (sourcemapGeneratedUrl && sourcemap) {
+            writeFileSync(
+              new URL(sourcemapGeneratedUrl),
+              JSON.stringify(sourcemap, null, "  "),
+            )
+          }
         }
       }
     }
@@ -671,6 +661,9 @@ const memoizeCook = (cook) => {
 }
 
 const applyReferenceEffectsOnUrlInfo = (reference, urlInfo, context) => {
+  if (reference.shouldHandle) {
+    urlInfo.shouldHandle = true
+  }
   Object.assign(urlInfo.data, reference.data)
   Object.assign(urlInfo.timing, reference.timing)
   if (reference.injected) {

package/src/omega/url_graph/url_graph_report.js

@@ -37,8 +37,8 @@ const createUrlGraphReport = (urlGraph) => {
     const urlInfo = urlInfos[url]
     // ignore:
     // - inline files: they are already taken into account in the file where they appear
-    // - external files: we don't know their content
-    if (urlInfo.isInline || urlInfo.external) {
+    // - ignored files: we don't know their content
+    if (urlInfo.isInline || !urlInfo.shouldHandle) {
       return
     }
     // file loaded via import assertion are already inside the graph

package/src/omega/url_graph.js

@@ -188,7 +188,7 @@ const createUrlInfo = (url) => {
     generatedUrl: null,
     isInline: false,
     inlineUrlSite: null,
-    external: false,
+    shouldHandle: undefined,
     originalContent: undefined,
     content: undefined,
     contentEtag: null,

package/src/plugins/autoreload/dev_sse/jsenv_plugin_dev_sse_client.js

@@ -1,20 +1,15 @@
-import { urlIsInsideOf } from "@jsenv/filesystem"
-
 import {
   parseHtmlString,
   stringifyHtmlAst,
   injectScriptAsEarlyAsPossible,
   createHtmlNode,
 } from "@jsenv/utils/html_ast/html_ast.js"
-import { jsenvRootDirectoryUrl } from "@jsenv/core/src/jsenv_root_directory_url.js"
 
-export const jsenvPluginDevSSEClient = ({ rootDirectoryUrl }) => {
-  const preferSourceFiles =
-    rootDirectoryUrl === jsenvRootDirectoryUrl ||
-    urlIsInsideOf(rootDirectoryUrl, jsenvRootDirectoryUrl)
-  const eventSourceClientFileUrl = preferSourceFiles
-    ? new URL("./client/event_source_client.js", import.meta.url).href
-    : new URL("./dist/event_source_client.js", jsenvRootDirectoryUrl).href
+export const jsenvPluginDevSSEClient = () => {
+  const eventSourceClientFileUrl = new URL(
+    "./client/event_source_client.js",
+    import.meta.url,
+  ).href
 
   return {
     name: "jsenv:dev_sse_client",

package/src/plugins/autoreload/jsenv_plugin_autoreload.js

@@ -14,9 +14,7 @@ export const jsenvPluginAutoreload = ({
   }
   return [
     jsenvPluginHmr(),
-    jsenvPluginDevSSEClient({
-      rootDirectoryUrl,
-    }),
+    jsenvPluginDevSSEClient(),
     jsenvPluginDevSSEServer({
       rootDirectoryUrl,
       urlGraph,