@jsenv/core 27.0.0-alpha.63 → 27.0.0-alpha.66

package/src/omega/kitchen.js

@@ -12,9 +12,9 @@ import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
 import { normalizeUrl, setUrlFilename } from "@jsenv/utils/urls/url_utils.js"
 
 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,
@@ -45,7 +45,7 @@ export const createKitchen = ({
     build: true,
   }[scenario],
   sourcemapsRelativeSources,
-  runtimeCompat = defaultRuntimeCompat,
+  runtimeCompat,
   writeGeneratedFiles,
 }) => {
   const pluginController = createPluginController({
@@ -53,7 +53,7 @@ export const createKitchen = ({
     scenario,
   })
   const jsenvDirectoryUrl = new URL(".jsenv/", rootDirectoryUrl).href
-  const baseContext = {
+  const kitchenContext = {
     signal,
     logger,
     rootDirectoryUrl,
@@ -85,7 +85,7 @@ export const createKitchen = ({
     specifierColumn,
     baseUrl,
     isOriginalPosition,
-    external = false,
+    shouldHandle,
     isInline = false,
     injected = false,
     isRessourceHint = false,
@@ -121,7 +121,7 @@ export const createKitchen = ({
       specifierColumn,
       baseUrl,
       isOriginalPosition,
-      external,
+      shouldHandle,
       isInline,
       injected,
       isRessourceHint,
@@ -144,22 +144,17 @@ export const createKitchen = ({
       let resolvedUrl = pluginController.callHooksUntil(
         "resolveUrl",
         reference,
-        baseContext,
+        kitchenContext,
       )
       if (!resolvedUrl) {
         throw new Error(`NO_RESOLVE`)
       }
       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,
-        baseContext,
+        kitchenContext,
         (returnValue) => {
           const normalizedReturnValue = normalizeUrl(returnValue)
           if (normalizedReturnValue === reference.url) {
@@ -172,7 +167,7 @@ export const createKitchen = ({
       )
 
       const urlInfo = urlGraph.reuseOrCreateUrlInfo(reference.url)
-      applyReferenceEffectsOnUrlInfo(reference, urlInfo, baseContext)
+      applyReferenceEffectsOnUrlInfo(reference, urlInfo, kitchenContext)
 
       const referenceUrlObject = new URL(reference.url)
       reference.searchParams = referenceUrlObject.searchParams
@@ -186,7 +181,7 @@ export const createKitchen = ({
       pluginController.callHooks(
         "transformUrlSearchParams",
         reference,
-        baseContext,
+        kitchenContext,
         (returnValue) => {
           Object.keys(returnValue).forEach((key) => {
             referenceUrlObject.searchParams.set(key, returnValue[key])
@@ -197,10 +192,10 @@ export const createKitchen = ({
       const returnValue = pluginController.callHooksUntil(
         "formatUrl",
         reference,
-        baseContext,
+        kitchenContext,
       )
       reference.generatedSpecifier = returnValue || reference.generatedUrl
-      reference.generatedSpecifier = urlSpecifierFormat.encode(reference)
+      reference.generatedSpecifier = urlSpecifierEncoding.encode(reference)
       return urlInfo
     } catch (error) {
       throw createResolveUrlError({
@@ -210,7 +205,7 @@ export const createKitchen = ({
       })
     }
   }
-  baseContext.resolveReference = resolveReference
+  kitchenContext.resolveReference = resolveReference
   const urlInfoTransformer = createUrlInfoTransformer({
     logger,
     urlGraph,
@@ -257,11 +252,7 @@ export const createKitchen = ({
     },
   })
 
-  const fetchUrlContent = async ({ reference, urlInfo, context }) => {
-    if (reference.external) {
-      urlInfo.external = true
-      return
-    }
+  const fetchUrlContent = async (urlInfo, { reference, context }) => {
     try {
       const fetchUrlContentReturnValue =
         await pluginController.callAsyncHooksUntil(
@@ -272,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 {
@@ -342,238 +328,231 @@ export const createKitchen = ({
     await urlInfoTransformer.initTransformations(urlInfo, context)
   }
 
-  const _cook = async ({
-    reference,
-    urlInfo,
-    outDirectoryUrl,
+  const _cook = async (urlInfo, dishContext) => {
     // during dev/test clientRuntimeCompat is a single runtime
     // during build clientRuntimeCompat is runtimeCompat
-    clientRuntimeCompat = runtimeCompat,
-    cookDuringCook = cook,
-  }) => {
-    baseContext.isSupportedOnCurrentClients = (feature) => {
+    const { clientRuntimeCompat = runtimeCompat } = dishContext
+    kitchenContext.isSupportedOnCurrentClients = (feature) => {
       return RUNTIME_COMPAT.isSupported(clientRuntimeCompat, feature)
     }
     const context = {
-      ...baseContext,
-      reference,
-      outDirectoryUrl,
+      ...kitchenContext,
+      ...dishContext,
       clientRuntimeCompat,
-      cook: (params) => {
-        return cookDuringCook({
-          outDirectoryUrl,
-          clientRuntimeCompat,
-          ...params,
-        })
-      },
-      fetchUrlContent: (params) => {
-        return fetchUrlContent({
-          context,
-          ...params,
-        })
-      },
     }
-
-    // "fetchUrlContent" hook
-    await fetchUrlContent({ reference, urlInfo, context })
-    if (urlInfo.external) {
-      return
-    }
-
-    // parsing
-    const references = []
-    const addReference = (props) => {
-      const reference = createReference({
-        parentUrl: urlInfo.url,
-        ...props,
+    const { cookDuringCook = cook } = dishContext
+    context.cook = (urlInfo, nestedDishContext) => {
+      return cookDuringCook(urlInfo, {
+        outDirectoryUrl: dishContext.outDirectoryUrl,
+        clientRuntimeCompat: dishContext.clientRuntimeCompat,
+        ...nestedDishContext,
       })
-      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,
-        })
-      },
-      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,
+    context.fetchUrlContent = (urlInfo, { reference }) => {
+      return fetchUrlContent(urlInfo, { reference, context })
+    }
+
+    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[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,
-        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,
-        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
@@ -598,44 +577,34 @@ export const createKitchen = ({
       },
     )
   }
-  const cook = memoizeCook(async ({ urlInfo, outDirectoryUrl, ...rest }) => {
-    outDirectoryUrl = outDirectoryUrl ? String(outDirectoryUrl) : undefined
-
-    const writeFiles = ({ gotError }) => {
-      if (!writeGeneratedFiles || !outDirectoryUrl) {
-        return
-      }
-      const { generatedUrl } = urlInfo
-      // writing result inside ".jsenv" directory (debug purposes)
-      if (!generatedUrl || !generatedUrl.startsWith("file:")) {
-        return
-      }
-      // use writeSync to avoid concurrency on writing the file
-      const write = gotError ? writeFileSync : writeFileSync
-      write(new URL(generatedUrl), urlInfo.content)
-      const { sourcemapGeneratedUrl, sourcemap } = urlInfo
-      if (sourcemapGeneratedUrl && sourcemap) {
-        write(
-          new URL(sourcemapGeneratedUrl),
-          JSON.stringify(sourcemap, null, "  "),
-        )
-      }
+  const cook = memoizeCook(async (urlInfo, context) => {
+    if (!writeGeneratedFiles || !context.outDirectoryUrl) {
+      await _cook(urlInfo, context)
+      return
     }
-
+    // writing result inside ".jsenv" directory (debug purposes)
     try {
-      await _cook({
-        urlInfo,
-        outDirectoryUrl,
-        ...rest,
-      })
-      writeFiles({ gotError: false })
-    } catch (e) {
-      writeFiles({ gotError: true })
-      throw e
+      await _cook(urlInfo, context)
+    } finally {
+      const { generatedUrl } = urlInfo
+      if (generatedUrl && generatedUrl.startsWith("file:")) {
+        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, "  "),
+            )
+          }
+        }
+      }
     }
   })
-
-  baseContext.cook = cook
+  kitchenContext.fetchUrlContent = fetchUrlContent
+  kitchenContext.cook = cook
 
   const prepareEntryPoint = (params) => {
     const entryReference = createReference(params)
@@ -654,7 +623,7 @@ export const createKitchen = ({
     urlInfoTransformer,
     rootDirectoryUrl,
     jsenvDirectoryUrl,
-    baseContext,
+    kitchenContext,
     cook,
     prepareEntryPoint,
     injectReference,
@@ -663,8 +632,7 @@ export const createKitchen = ({
 
 const memoizeCook = (cook) => {
   const pendingDishes = new Map()
-  return async (params) => {
-    const { urlInfo } = params
+  return async (urlInfo, context) => {
     const { url, modifiedTimestamp } = urlInfo
     const pendingDish = pendingDishes.get(url)
     if (pendingDish) {
@@ -679,7 +647,7 @@ const memoizeCook = (cook) => {
       pendingDishes.delete(url)
     }
     const timestamp = Date.now()
-    const promise = cook(params)
+    const promise = cook(urlInfo, context)
     pendingDishes.set(url, {
       timestamp,
       promise,
@@ -693,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) {
@@ -833,66 +804,6 @@ const determineFileUrlForOutDirectory = ({ urlInfo, context }) => {
   })
 }
 
-const urlSpecifierFormat = {
-  encode: (reference) => {
-    const { generatedSpecifier } = reference
-    if (generatedSpecifier.then) {
-      return generatedSpecifier.then((value) => {
-        reference.generatedSpecifier = value
-        return urlSpecifierFormat.encode(reference)
-      })
-    }
-    // allow plugin to return a function to bypas default formatting
-    // (which is to use JSON.stringify when url is referenced inside js)
-    if (typeof generatedSpecifier === "function") {
-      return generatedSpecifier()
-    }
-    const formatter = formatters[reference.type]
-    const value = formatter
-      ? formatter.encode(generatedSpecifier)
-      : generatedSpecifier
-    if (reference.escape) {
-      return reference.escape(value)
-    }
-    return value
-  },
-  decode: (reference) => {
-    const formatter = formatters[reference.type]
-    return formatter
-      ? formatter.decode(reference.generatedSpecifier)
-      : reference.generatedSpecifier
-  },
-}
-const formatters = {
-  "js_import_export": { encode: JSON.stringify, decode: JSON.parse },
-  "js_url_specifier": { encode: JSON.stringify, decode: JSON.parse },
-  "css_@import": { encode: JSON.stringify, code: JSON.stringify },
-  // https://github.com/webpack-contrib/css-loader/pull/627/files
-  "css_url": {
-    encode: (url) => {
-      // If url is already wrapped in quotes, remove them
-      url = formatters.css_url.decode(url)
-      // Should url be wrapped?
-      // See https://drafts.csswg.org/css-values-3/#urls
-      if (/["'() \t\n]/.test(url)) {
-        return `"${url.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`
-      }
-      return url
-    },
-    decode: (url) => {
-      const firstChar = url[0]
-      const lastChar = url[url.length - 1]
-      if (firstChar === `"` && lastChar === `"`) {
-        return url.slice(1, -1)
-      }
-      if (firstChar === `'` && lastChar === `'`) {
-        return url.slice(1, -1)
-      }
-      return url
-    },
-  },
-}
-
 // import { getOriginalPosition } from "@jsenv/core/src/utils/sourcemap/original_position.js"
 // const getUrlSite = async (
 //   urlInfo,