@jsenv/core 28.1.3 → 28.2.0

package/src/omega/kitchen.js

@@ -7,7 +7,7 @@ import {
   setUrlFilename,
 } from "@jsenv/urls"
 import { writeFileSync, ensureWindowsDriveLetter } from "@jsenv/filesystem"
-import { createLogger, createDetailedMessage } from "@jsenv/log"
+import { createLogger, createDetailedMessage, ANSI } from "@jsenv/log"
 import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
 
 import { createPluginController } from "../plugins/plugin_controller.js"
@@ -40,13 +40,13 @@ export const createKitchen = ({
   sourcemapsSourcesContent,
   sourcemapsRelativeSources,
   writeGeneratedFiles,
+  outDirectoryUrl,
 }) => {
   const logger = createLogger({ logLevel })
   const pluginController = createPluginController({
     plugins,
     scenarios,
   })
-  const jsenvDirectoryUrl = new URL(".jsenv/", rootDirectoryUrl).href
   const kitchenContext = {
     signal,
     logger,
@@ -62,6 +62,7 @@ export const createKitchen = ({
       return RUNTIME_COMPAT.isSupported(runtimeCompat, feature)
     },
     sourcemaps,
+    outDirectoryUrl,
   }
   pluginController.callHooks("init", kitchenContext)
   const createReference = ({
@@ -86,20 +87,22 @@ export const createKitchen = ({
     isOriginalPosition,
     shouldHandle,
     isEntryPoint = false,
-    isInline = false,
-    injected = false,
     isResourceHint = false,
-    dependsOnPackageJson,
+    isImplicit = false,
+    hasVersioningEffect = false,
+    injected = false,
+    isInline = false,
     content,
     contentType,
     assert,
     assertNode,
     typePropertyNode,
+    debug = false,
   }) => {
     if (typeof specifier !== "string") {
       throw new TypeError(`"specifier" must be a string, got ${specifier}`)
     }
-    return {
+    const reference = {
       original: null,
       prev: null,
       next: null,
@@ -107,6 +110,10 @@ export const createKitchen = ({
       node,
       trace,
       parentUrl,
+      url: null,
+      searchParams: null,
+      generatedUrl: null,
+      generatedSpecifier: null,
       type,
       subtype,
       expectedContentType,
@@ -120,60 +127,94 @@ export const createKitchen = ({
       specifierEnd,
       specifierLine,
       specifierColumn,
-      baseUrl,
       isOriginalPosition,
+      baseUrl,
       shouldHandle,
       isEntryPoint,
-      isInline,
-      injected,
       isResourceHint,
-      dependsOnPackageJson,
+      isImplicit,
+      hasVersioningEffect,
+      injected,
+      timing: {},
       // for inline resources the reference contains the content
+      isInline,
       content,
       contentType,
-      timing: {},
+      escape: null,
+      // import assertions (maybe move to data?)
       assert,
       assertNode,
       typePropertyNode,
+      mutation: null,
+      debug,
     }
+    // Object.preventExtensions(reference) // useful to ensure all properties are declared here
+    return reference
   }
-  const mutateReference = (reference, newReference) => {
+  const updateReference = (reference, newReference) => {
     reference.next = newReference
-    newReference.prev = reference
     newReference.original = reference.original || reference
-    //  newReference.isEntryPoint = reference.isEntryPoint
+
+    newReference.prev = reference
   }
   const resolveReference = (reference, context = kitchenContext) => {
+    const referenceContext = {
+      ...context,
+      resolveReference: (reference, context = referenceContext) =>
+        resolveReference(reference, context),
+    }
     try {
       let resolvedUrl = pluginController.callHooksUntil(
         "resolveUrl",
         reference,
-        context,
+        referenceContext,
       )
       if (!resolvedUrl) {
         throw new Error(`NO_RESOLVE`)
       }
+      if (resolvedUrl.includes("?debug")) {
+        reference.debug = true
+      }
       resolvedUrl = normalizeUrl(resolvedUrl)
+      let referencedUrlObject = new URL(resolvedUrl)
+      let searchParams = referencedUrlObject.searchParams
       reference.url = resolvedUrl
+      reference.searchParams = searchParams
+      if (reference.debug) {
+        logger.debug(`url resolved by "${
+          pluginController.getLastPluginUsed().name
+        }"
+${ANSI.color(reference.specifier, ANSI.GREY)} ->
+${ANSI.color(reference.url, ANSI.YELLOW)}
+`)
+      }
       pluginController.callHooks(
         "redirectUrl",
         reference,
-        context,
-        (returnValue) => {
+        referenceContext,
+        (returnValue, plugin) => {
           const normalizedReturnValue = normalizeUrl(returnValue)
           if (normalizedReturnValue === reference.url) {
             return
           }
-          const previousReference = { ...reference }
+          if (reference.debug) {
+            logger.debug(
+              `url redirected by "${plugin.name}"
+${ANSI.color(reference.url, ANSI.GREY)} ->
+${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
+`,
+            )
+          }
+          const prevReference = { ...reference }
+          updateReference(prevReference, reference)
+          referencedUrlObject = new URL(normalizedReturnValue)
+          searchParams = referencedUrlObject.searchParams
           reference.url = normalizedReturnValue
-          mutateReference(previousReference, reference)
+          reference.searchParams = searchParams
         },
       )
-
-      const referenceUrlObject = new URL(reference.url)
-      reference.searchParams = referenceUrlObject.searchParams
       reference.generatedUrl = reference.url
-      if (reference.searchParams.has("entry_point")) {
+      if (searchParams.has("entry_point")) {
         reference.isEntryPoint = true
       }
 
@@ -189,22 +230,22 @@ export const createKitchen = ({
       pluginController.callHooks(
         "transformUrlSearchParams",
         reference,
-        context,
+        referenceContext,
         (returnValue) => {
           Object.keys(returnValue).forEach((key) => {
-            referenceUrlObject.searchParams.set(key, returnValue[key])
+            searchParams.set(key, returnValue[key])
           })
-          reference.generatedUrl = normalizeUrl(referenceUrlObject.href)
+          reference.generatedUrl = normalizeUrl(referencedUrlObject.href)
         },
       )
       const returnValue = pluginController.callHooksUntil(
         "formatUrl",
         reference,
-        context,
+        referenceContext,
       )
       reference.generatedSpecifier = returnValue || reference.generatedUrl
       reference.generatedSpecifier = urlSpecifierEncoding.encode(reference)
-      return urlInfo
+      return [reference, urlInfo]
     } catch (error) {
       throw createResolveUrlError({
         pluginController,
@@ -224,17 +265,18 @@ export const createKitchen = ({
     sourcemapsRelativeSources,
     clientRuntimeCompat,
     injectSourcemapPlaceholder: ({ urlInfo, specifier }) => {
-      const sourcemapReference = createReference({
-        trace: {
-          message: `sourcemap comment placeholder`,
-          url: urlInfo.url,
-        },
-        type: "sourcemap_comment",
-        subtype: urlInfo.contentType === "text/javascript" ? "js" : "css",
-        parentUrl: urlInfo.url,
-        specifier,
-      })
-      const sourcemapUrlInfo = resolveReference(sourcemapReference)
+      const [sourcemapReference, sourcemapUrlInfo] = resolveReference(
+        createReference({
+          trace: {
+            message: `sourcemap comment placeholder`,
+            url: urlInfo.url,
+          },
+          type: "sourcemap_comment",
+          subtype: urlInfo.contentType === "text/javascript" ? "js" : "css",
+          parentUrl: urlInfo.url,
+          specifier,
+        }),
+      )
       sourcemapUrlInfo.type = "sourcemap"
       return [sourcemapReference, sourcemapUrlInfo]
     },
@@ -251,27 +293,31 @@ export const createKitchen = ({
         line: specifierLine,
         column: specifierColumn,
       })
-      const sourcemapReference = createReference({
-        trace: traceFromUrlSite(sourcemapUrlSite),
-        type,
-        parentUrl: urlInfo.url,
-        specifier,
-        specifierLine,
-        specifierColumn,
-      })
-      const sourcemapUrlInfo = resolveReference(sourcemapReference)
+      const [sourcemapReference, sourcemapUrlInfo] = resolveReference(
+        createReference({
+          trace: traceFromUrlSite(sourcemapUrlSite),
+          type,
+          parentUrl: urlInfo.url,
+          specifier,
+          specifierLine,
+          specifierColumn,
+        }),
+      )
       sourcemapUrlInfo.type = "sourcemap"
       return [sourcemapReference, sourcemapUrlInfo]
     },
   })
 
-  const fetchUrlContent = async (urlInfo, { reference, context }) => {
+  const fetchUrlContent = async (
+    urlInfo,
+    { reference, contextDuringFetch },
+  ) => {
     try {
       const fetchUrlContentReturnValue =
         await pluginController.callAsyncHooksUntil(
           "fetchUrlContent",
           urlInfo,
-          context,
+          contextDuringFetch,
         )
       if (!fetchUrlContentReturnValue) {
         logger.warn(
@@ -353,10 +399,11 @@ export const createKitchen = ({
     }
     urlInfo.generatedUrl = determineFileUrlForOutDirectory({
       urlInfo,
-      context,
+      context: contextDuringFetch,
     })
-    await urlInfoTransformer.initTransformations(urlInfo, context)
+    await urlInfoTransformer.initTransformations(urlInfo, contextDuringFetch)
   }
+  kitchenContext.fetchUrlContent = fetchUrlContent
 
   const _cook = async (urlInfo, dishContext) => {
     const context = {
@@ -371,40 +418,30 @@ export const createKitchen = ({
       })
     }
     context.fetchUrlContent = (urlInfo, { reference }) => {
-      return fetchUrlContent(urlInfo, { reference, context })
+      return fetchUrlContent(urlInfo, {
+        reference,
+        contextDuringFetch: context,
+      })
     }
 
     if (urlInfo.shouldHandle) {
-      // "fetchUrlContent" hook
-      await fetchUrlContent(urlInfo, { reference: context.reference, context })
-
-      // parsing
+      // references
       const references = []
-      const addReference = (props) => {
-        const reference = createReference({
-          parentUrl: urlInfo.url,
-          ...props,
-        })
-        references.push(reference)
-        const referencedUrlInfo = resolveReference(reference, context)
-        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
+      context.referenceUtils = {
+        _references: references,
+        add: (props) => {
+          const [reference, referencedUrlInfo] = resolveReference(
+            createReference({
+              parentUrl: urlInfo.url,
+              ...props,
+            }),
+            context,
+          )
+          references.push(reference)
+          return [reference, referencedUrlInfo]
         },
+        find: (predicate) => references.find(predicate),
+        readGeneratedSpecifier,
         found: ({ trace, ...rest }) => {
           if (trace === undefined) {
             trace = traceFromUrlSite(
@@ -416,8 +453,8 @@ export const createKitchen = ({
               }),
             )
           }
-          // console.log(trace)
-          return addReference({
+          // console.log(trace.message)
+          return context.referenceUtils.add({
             trace,
             ...rest,
           })
@@ -434,7 +471,7 @@ export const createKitchen = ({
           const parentContent = isOriginalPosition
             ? urlInfo.originalContent
             : urlInfo.content
-          return addReference({
+          return context.referenceUtils.add({
             trace: traceFromUrlSite({
               url: parentUrl,
               content: parentContent,
@@ -453,14 +490,15 @@ export const createKitchen = ({
           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, context)
+          const [newReference, newUrlInfo] = resolveReference(
+            createReference({
+              ...currentReference,
+              ...newReferenceParams,
+            }),
+            context,
+          )
+          updateReference(currentReference, newReference)
+          references[index] = newReference
           const currentUrlInfo = context.urlGraph.getUrlInfo(
             currentReference.url,
           )
@@ -471,7 +509,7 @@ export const createKitchen = ({
           ) {
             context.urlGraph.deleteUrlInfo(currentReference.url)
           }
-          return [nextReference, newUrlInfo]
+          return [newReference, newUrlInfo]
         },
         becomesInline: (
           reference,
@@ -490,7 +528,7 @@ export const createKitchen = ({
           const parentContent = isOriginalPosition
             ? urlInfo.originalContent
             : urlInfo.content
-          return referenceUtils.update(reference, {
+          return context.referenceUtils.update(reference, {
             trace: traceFromUrlSite({
               url: parentUrl,
               content: parentContent,
@@ -515,7 +553,7 @@ export const createKitchen = ({
               column,
             })
           }
-          return addReference({
+          return context.referenceUtils.add({
             trace,
             injected: true,
             ...rest,
@@ -534,9 +572,13 @@ export const createKitchen = ({
         },
       }
 
+      // "fetchUrlContent" hook
+      await fetchUrlContent(urlInfo, {
+        reference: context.reference,
+        contextDuringFetch: context,
+      })
+
       // "transform" hook
-      urlInfo.references = references
-      context.referenceUtils = referenceUtils
       try {
         await pluginController.callAsyncHooks(
           "transformUrlContent",
@@ -605,7 +647,7 @@ export const createKitchen = ({
     )
   }
   const cook = memoizeCook(async (urlInfo, context) => {
-    if (!writeGeneratedFiles || !context.outDirectoryUrl) {
+    if (!writeGeneratedFiles || !outDirectoryUrl) {
       await _cook(urlInfo, context)
       return
     }
@@ -630,23 +672,24 @@ export const createKitchen = ({
       }
     }
   })
-  kitchenContext.fetchUrlContent = fetchUrlContent
   kitchenContext.cook = cook
 
   const prepareEntryPoint = (params) => {
-    const entryReference = createReference(params)
-    entryReference.isEntryPoint = true
-    const entryUrlInfo = resolveReference(entryReference)
-    return [entryReference, entryUrlInfo]
+    return resolveReference(
+      createReference({
+        ...params,
+        isEntryPoint: true,
+      }),
+    )
   }
+  kitchenContext.prepareEntryPoint = prepareEntryPoint
 
   const injectReference = (params) => {
-    const ref = createReference(params)
-    const urlInfo = resolveReference(ref)
-    return [ref, urlInfo]
+    return resolveReference(createReference(params))
   }
+  kitchenContext.injectReference = injectReference
 
-  const fetchOriginalUrlInfo = async ({
+  const getWithoutSearchParam = ({
     urlInfo,
     context,
     searchParam,
@@ -655,50 +698,65 @@ export const createKitchen = ({
     const urlObject = new URL(urlInfo.url)
     const { searchParams } = urlObject
     if (!searchParams.has(searchParam)) {
-      return null
+      return [null, null]
     }
     searchParams.delete(searchParam)
-    const originalUrl = urlObject.href
-    const originalReference = {
-      ...(context.reference.original || context.reference),
+    const originalRef = context.reference.original || context.reference
+    const referenceWithoutSearchParam = {
+      ...originalRef,
+      original: originalRef,
+      searchParams,
+      data: { ...originalRef.data },
       expectedType,
+      specifier: context.reference.specifier
+        .replace(`?${searchParam}`, "")
+        .replace(`&${searchParam}`, ""),
+      url: urlObject.href,
+      generatedSpecifier: null,
+      generatedUrl: null,
     }
-    originalReference.url = originalUrl
-    const originalUrlInfo = context.urlGraph.reuseOrCreateUrlInfo(
-      originalReference.url,
+    const urlInfoWithoutSearchParam = context.urlGraph.reuseOrCreateUrlInfo(
+      referenceWithoutSearchParam.url,
     )
-    if (originalUrlInfo.originalUrl === undefined) {
+    if (urlInfoWithoutSearchParam.originalUrl === undefined) {
       applyReferenceEffectsOnUrlInfo(
-        originalReference,
-        originalUrlInfo,
+        referenceWithoutSearchParam,
+        urlInfoWithoutSearchParam,
         context,
       )
     }
-    await context.fetchUrlContent(originalUrlInfo, {
-      reference: originalReference,
-    })
-    if (
-      originalUrlInfo.dependents.size === 0
-      // && context.scenarios.build
-    ) {
-      context.urlGraph.deleteUrlInfo(originalUrlInfo.url)
-    }
-    return originalUrlInfo
+    return [referenceWithoutSearchParam, urlInfoWithoutSearchParam]
   }
-  kitchenContext.fetchOriginalUrlInfo = fetchOriginalUrlInfo
+  kitchenContext.getWithoutSearchParam = getWithoutSearchParam
 
   return {
     pluginController,
     urlInfoTransformer,
     rootDirectoryUrl,
-    jsenvDirectoryUrl,
     kitchenContext,
     cook,
-    prepareEntryPoint,
+    createReference,
     injectReference,
   }
 }
 
+// "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"
+
+const readGeneratedSpecifier = (reference) => {
+  if (reference.generatedSpecifier.then) {
+    return reference.generatedSpecifier.then((value) => {
+      reference.generatedSpecifier = value
+      return value
+    })
+  }
+  return reference.generatedSpecifier
+}
+
 const memoizeCook = (cook) => {
   const pendingDishes = new Map()
   return async (urlInfo, context) => {
@@ -753,7 +811,7 @@ const applyReferenceEffectsOnUrlInfo = (reference, urlInfo, context) => {
   Object.assign(urlInfo.data, reference.data)
   Object.assign(urlInfo.timing, reference.timing)
   if (reference.injected) {
-    urlInfo.data.injected = true
+    urlInfo.injected = true
   }
   if (reference.filename) {
     urlInfo.filename = reference.filename
@@ -777,20 +835,6 @@ const applyReferenceEffectsOnUrlInfo = (reference, urlInfo, context) => {
       : reference.content
     urlInfo.content = reference.content
   }
-
-  const { dependsOnPackageJson } = reference
-  urlInfo.dependsOnPackageJson = dependsOnPackageJson
-  const relatedUrlInfos = context.urlGraph.getRelatedUrlInfos(
-    reference.parentUrl,
-  )
-  relatedUrlInfos.forEach((relatedUrlInfo) => {
-    if (relatedUrlInfo.dependsOnPackageJson) {
-      // the url may depend due to an other reference
-      // in that case keep dependsOnPackageJson to true
-      return
-    }
-    relatedUrlInfo.dependsOnPackageJson = dependsOnPackageJson
-  })
 }
 
 const adjustUrlSite = (urlInfo, { urlGraph, url, line, column }) => {