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

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 {
@@ -292,6 +277,7 @@ export const createKitchen = ({
         type,
         subtype,
         contentType = "application/octet-stream",
+        originalUrl,
         originalContent,
         content,
         sourcemap,
@@ -313,7 +299,8 @@ export const createKitchen = ({
           subtype: urlInfo.subtype,
         })
       urlInfo.contentType = contentType
-      // during build urls info are reused and load returns originalContent
+      // during build urls info are reused and load returns originalUrl/originalContent
+      urlInfo.originalUrl = originalUrl || urlInfo.originalUrl
       urlInfo.originalContent =
         originalContent === undefined ? content : originalContent
       urlInfo.content = content
@@ -367,206 +354,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,
+      // parsing
+      const references = []
+      const addReference = (props) => {
+        const reference = createReference({
+          parentUrl: urlInfo.url,
+          ...props,
         })
-      },
-      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,
-        })
-      },
-      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 +590,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, "  "),
+            )
+          }
         }
       }
     }
@@ -628,6 +620,44 @@ export const createKitchen = ({
     return [ref, urlInfo]
   }
 
+  const fetchOriginalUrlInfo = async ({
+    urlInfo,
+    context,
+    searchParam,
+    expectedType,
+  }) => {
+    const urlObject = new URL(urlInfo.url)
+    const { searchParams } = urlObject
+    if (!searchParams.has(searchParam)) {
+      return null
+    }
+    searchParams.delete(searchParam)
+    const originalUrl = urlObject.href
+    const originalReference = {
+      ...(context.reference.original || context.reference),
+      expectedType,
+    }
+    originalReference.url = originalUrl
+    const originalUrlInfo = context.urlGraph.reuseOrCreateUrlInfo(
+      originalReference.url,
+    )
+    if (originalUrlInfo.originalUrl === undefined) {
+      applyReferenceEffectsOnUrlInfo(
+        originalReference,
+        originalUrlInfo,
+        context,
+      )
+    }
+    await context.fetchUrlContent(originalUrlInfo, {
+      reference: originalReference,
+    })
+    if (originalUrlInfo.dependents.size === 0) {
+      context.urlGraph.deleteUrlInfo(originalUrlInfo.url)
+    }
+    return originalUrlInfo
+  }
+  kitchenContext.fetchOriginalUrlInfo = fetchOriginalUrlInfo
+
   return {
     pluginController,
     urlInfoTransformer,
@@ -671,6 +701,11 @@ const memoizeCook = (cook) => {
 }
 
 const applyReferenceEffectsOnUrlInfo = (reference, urlInfo, context) => {
+  if (reference.shouldHandle) {
+    urlInfo.shouldHandle = true
+  }
+  urlInfo.originalUrl = urlInfo.originalUrl || reference.url
+
   Object.assign(urlInfo.data, reference.data)
   Object.assign(urlInfo.timing, reference.timing)
   if (reference.injected) {

package/src/omega/server/file_service.js

@@ -143,7 +143,7 @@ export const createFileService = ({
           body: urlInfo.content,
         }
       }
-      if (code === "EISDIR") {
+      if (code === "DIRECTORY_REFERENCE_NOT_ALLOWED") {
         return serveDirectory(reference.url, {
           headers: {
             accept: "text/html",

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/url_info_transformations.js

@@ -34,14 +34,14 @@ export const createUrlInfoTransformer = ({
         ))
     if (sourcemap.sources && sourcemap.sources.length > 1) {
       sourcemap.sources = sourcemap.sources.map(
-        (source) => new URL(source, urlInfo.data.rawUrl || urlInfo.url).href,
+        (source) => new URL(source, urlInfo.originalUrl).href,
       )
       if (!wantSourcesContent) {
         sourcemap.sourcesContent = undefined
       }
       return sourcemap
     }
-    sourcemap.sources = [urlInfo.data.rawUrl || urlInfo.url]
+    sourcemap.sources = [urlInfo.originalUrl]
     sourcemap.sourcesContent = [urlInfo.originalContent]
     if (!wantSourcesContent) {
       sourcemap.sourcesContent = undefined
@@ -74,6 +74,7 @@ export const createUrlInfoTransformer = ({
 
     // already loaded during "load" hook (happens during build)
     if (urlInfo.sourcemap) {
+      urlInfo.sourcemap = normalizeSourcemap(urlInfo, urlInfo.sourcemap)
       return
     }
     // check for existing sourcemap for this content
@@ -92,8 +93,9 @@ export const createUrlInfoTransformer = ({
       })
       try {
         await context.cook(sourcemapUrlInfo, { reference: sourcemapReference })
-        const sourcemap = JSON.parse(sourcemapUrlInfo.content)
-        urlInfo.sourcemap = normalizeSourcemap(urlInfo, sourcemap)
+        const sourcemapRaw = JSON.parse(sourcemapUrlInfo.content)
+        const sourcemap = normalizeSourcemap(urlInfo, sourcemapRaw)
+        urlInfo.sourcemap = sourcemap
       } catch (e) {
         logger.error(`Error while handling existing sourcemap: ${e.message}`)
         return
@@ -146,7 +148,7 @@ export const createUrlInfoTransformer = ({
       if (sourcemapsRelativeSources) {
         sourcemap.sources = sourcemap.sources.map((source) => {
           const sourceRelative = urlToRelativeUrl(source, urlInfo.url)
-          return sourceRelative
+          return sourceRelative || "."
         })
       }
       sourcemapUrlInfo.content = JSON.stringify(sourcemap, null, "  ")
@@ -163,6 +165,9 @@ export const createUrlInfoTransformer = ({
               : sourcemapReference.generatedSpecifier,
         })
       }
+    } else if (urlInfo.sourcemapReference) {
+      // in the end we don't use the sourcemap placeholder
+      urlGraph.deleteUrlInfo(urlInfo.sourcemapReference.url)
     }
     urlInfo.contentEtag = bufferToEtag(Buffer.from(urlInfo.content))
   }

package/src/omega/url_graph.js

@@ -184,11 +184,12 @@ const createUrlInfo = (url) => {
     subtype: undefined, // "worker", "service_worker", "shared_worker" for js, otherwise undefined
     contentType: "", // "text/html", "text/css", "text/javascript", "application/json", ...
     url,
-    filename: "",
+    originalUrl: undefined,
     generatedUrl: null,
+    filename: "",
     isInline: false,
     inlineUrlSite: null,
-    external: false,
+    shouldHandle: undefined,
     originalContent: undefined,
     content: undefined,
     contentEtag: null,