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

package/src/execute/runtimes/browsers/from_playwright.js

@@ -216,9 +216,14 @@ export const createRuntimeFromPlaywright = ({
       },
     })
     cleanupCallbackList.add(removeConsoleListener)
+    const actionOperation = Abort.startOperation()
+    actionOperation.addAbortSignal(signal)
     const winnerPromise = new Promise((resolve, reject) => {
       raceCallbacks(
         {
+          aborted: (cb) => {
+            return actionOperation.addAbortCallback(cb)
+          },
           // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-error
           error: (cb) => {
             return registerEvent({
@@ -317,6 +322,11 @@ export const createRuntimeFromPlaywright = ({
 
     const getResult = async () => {
       const winner = await winnerPromise
+      if (winner.name === "aborted") {
+        return {
+          status: "aborted",
+        }
+      }
       if (winner.name === "error" || winner.name === "pageerror") {
         const error = winner.data
         return {

package/src/execute/runtimes/node/node_process.js

@@ -162,6 +162,9 @@ nodeProcess.run = async ({
   const winnerPromise = new Promise((resolve) => {
     raceCallbacks(
       {
+        aborted: (cb) => {
+          return actionOperation.addAbortCallback(cb)
+        },
         // https://nodejs.org/api/child_process.html#child_process_event_disconnect
         // disconnect: (cb) => {
         //   return onceProcessEvent(childProcess, "disconnect", cb)
@@ -194,6 +197,11 @@ nodeProcess.run = async ({
       },
     })
     const winner = await winnerPromise
+    if (winner.name === "aborted") {
+      return {
+        status: "aborted",
+      }
+    }
     if (winner.name === "error") {
       const error = winner.data
       removeOutputListener()

package/src/omega/kitchen.js

@@ -1,18 +1,18 @@
 import {
   urlIsInsideOf,
   writeFileSync,
-  isFileSystemPath,
-  fileSystemPathToUrl,
   moveUrl,
   ensureWindowsDriveLetter,
 } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/logger"
 
+import { getCallerPosition } from "@jsenv/utils/src/caller_position.js"
 import { stringifyUrlSite } from "@jsenv/utils/urls/url_trace.js"
 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"
@@ -54,7 +54,7 @@ export const createKitchen = ({
     scenario,
   })
   const jsenvDirectoryUrl = new URL(".jsenv/", rootDirectoryUrl).href
-  const baseContext = {
+  const kitchenContext = {
     signal,
     logger,
     rootDirectoryUrl,
@@ -145,7 +145,7 @@ export const createKitchen = ({
       let resolvedUrl = pluginController.callHooksUntil(
         "resolveUrl",
         reference,
-        baseContext,
+        kitchenContext,
       )
       if (!resolvedUrl) {
         throw new Error(`NO_RESOLVE`)
@@ -160,7 +160,7 @@ export const createKitchen = ({
       pluginController.callHooks(
         "redirectUrl",
         reference,
-        baseContext,
+        kitchenContext,
         (returnValue) => {
           const normalizedReturnValue = normalizeUrl(returnValue)
           if (normalizedReturnValue === reference.url) {
@@ -173,7 +173,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
@@ -187,7 +187,7 @@ export const createKitchen = ({
       pluginController.callHooks(
         "transformUrlSearchParams",
         reference,
-        baseContext,
+        kitchenContext,
         (returnValue) => {
           Object.keys(returnValue).forEach((key) => {
             referenceUrlObject.searchParams.set(key, returnValue[key])
@@ -198,10 +198,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({
@@ -211,7 +211,7 @@ export const createKitchen = ({
       })
     }
   }
-  baseContext.resolveReference = resolveReference
+  kitchenContext.resolveReference = resolveReference
   const urlInfoTransformer = createUrlInfoTransformer({
     logger,
     urlGraph,
@@ -258,7 +258,7 @@ export const createKitchen = ({
     },
   })
 
-  const fetchUrlContent = async ({ reference, urlInfo, context }) => {
+  const fetchUrlContent = async (urlInfo, { reference, context }) => {
     if (reference.external) {
       urlInfo.external = true
       return
@@ -343,40 +343,32 @@ 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,
-        })
-      },
+    }
+    const { cookDuringCook = cook } = dishContext
+    context.cook = (urlInfo, nestedDishContext) => {
+      return cookDuringCook(urlInfo, {
+        outDirectoryUrl: dishContext.outDirectoryUrl,
+        clientRuntimeCompat: dishContext.clientRuntimeCompat,
+        ...nestedDishContext,
+      })
+    }
+    context.fetchUrlContent = (urlInfo, { reference }) => {
+      return fetchUrlContent(urlInfo, { reference, context })
     }
 
     // "fetchUrlContent" hook
-    await fetchUrlContent({ reference, urlInfo, context })
+    await fetchUrlContent(urlInfo, { reference: context.reference, context })
     if (urlInfo.external) {
       return
     }
@@ -504,21 +496,11 @@ export const createKitchen = ({
       },
       inject: ({ trace, ...rest }) => {
         if (trace === undefined) {
-          const { prepareStackTrace } = Error
-          Error.prepareStackTrace = (error, stack) => {
-            Error.prepareStackTrace = prepareStackTrace
-            return stack
-          }
-          const { stack } = new Error()
-          const callerCallsite = stack[1]
-          const fileName = callerCallsite.getFileName()
+          const { url, line, column } = getCallerPosition()
           trace = stringifyUrlSite({
-            url:
-              fileName && isFileSystemPath(fileName)
-                ? fileSystemPathToUrl(fileName)
-                : fileName,
-            line: callerCallsite.getLineNumber(),
-            column: callerCallsite.getColumnNumber(),
+            url,
+            line,
+            column,
           })
         }
         return addReference({
@@ -558,7 +540,7 @@ export const createKitchen = ({
     } catch (error) {
       throw createTransformUrlContentError({
         pluginController,
-        reference,
+        reference: context.reference,
         urlInfo,
         error,
       })
@@ -581,7 +563,7 @@ export const createKitchen = ({
     } catch (error) {
       throw createFinalizeUrlContentError({
         pluginController,
-        reference,
+        reference: context.reference,
         urlInfo,
         error,
       })
@@ -609,44 +591,30 @@ 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:")) {
+        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)
@@ -665,7 +633,7 @@ export const createKitchen = ({
     urlInfoTransformer,
     rootDirectoryUrl,
     jsenvDirectoryUrl,
-    baseContext,
+    kitchenContext,
     cook,
     prepareEntryPoint,
     injectReference,
@@ -674,8 +642,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) {
@@ -690,7 +657,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,
@@ -844,66 +811,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,

package/src/omega/server/file_service.js

@@ -44,24 +44,32 @@ export const createFileService = ({
     if (responseFromPlugin) {
       return responseFromPlugin
     }
-    const [reference, urlInfo] = kitchen.prepareEntryPoint({
-      parentUrl: inferParentFromRequest(request, rootDirectoryUrl),
-      type: "entry_point",
-      specifier: request.ressource,
-    })
+    let reference
+    const parentUrl = inferParentFromRequest(request, rootDirectoryUrl)
+    if (parentUrl) {
+      reference = urlGraph.inferReference(request.ressource, parentUrl)
+    }
+    if (!reference) {
+      const entryPoint = kitchen.prepareEntryPoint({
+        trace: parentUrl || rootDirectoryUrl,
+        parentUrl: parentUrl || rootDirectoryUrl,
+        type: "entry_point",
+        specifier: request.ressource,
+      })
+      reference = entryPoint[0]
+    }
+    const urlInfo = urlGraph.reuseOrCreateUrlInfo(reference.url)
+
     const ifNoneMatch = request.headers["if-none-match"]
     if (ifNoneMatch && urlInfo.contentEtag === ifNoneMatch) {
       return {
         status: 304,
         headers: {
           "cache-control": `private,max-age=0,must-revalidate`,
+          ...urlInfo.responseHeaders,
         },
       }
     }
-    const referenceFromGraph = urlGraph.inferReference(
-      reference.url,
-      reference.parentUrl,
-    )
     try {
       // urlInfo objects are reused, they must be "reset" before cooking them again
       if (
@@ -76,20 +84,21 @@ export const createFileService = ({
         urlInfo.type = null
         urlInfo.subtype = null
         urlInfo.timing = {}
+        urlInfo.responseHeaders = {}
       }
       const { runtimeName, runtimeVersion } = parseUserAgentHeader(
         request.headers["user-agent"],
       )
-      await kitchen.cook({
-        reference: referenceFromGraph || reference,
-        urlInfo,
+      await kitchen.cook(urlInfo, {
+        request,
+        reference,
+        clientRuntimeCompat: {
+          [runtimeName]: runtimeVersion,
+        },
         outDirectoryUrl:
           scenario === "dev"
             ? `${rootDirectoryUrl}.jsenv/${runtimeName}@${runtimeVersion}/`
             : `${rootDirectoryUrl}.jsenv/${scenario}/${runtimeName}@${runtimeVersion}/`,
-        clientRuntimeCompat: {
-          [runtimeName]: runtimeVersion,
-        },
       })
       let { response, contentType, content, contentEtag } = urlInfo
       if (response) {
@@ -103,6 +112,7 @@ export const createFileService = ({
           "content-length": Buffer.byteLength(content),
           "cache-control": `private,max-age=0,must-revalidate`,
           "eTag": contentEtag,
+          ...urlInfo.responseHeaders,
         },
         body: content,
         timing: urlInfo.timing,
@@ -167,7 +177,6 @@ export const createFileService = ({
   }
   return async (request) => {
     let response = await getResponse(request)
-
     return response
   }
 }
@@ -175,7 +184,15 @@ export const createFileService = ({
 const inferParentFromRequest = (request, rootDirectoryUrl) => {
   const { referer } = request.headers
   if (!referer) {
-    return rootDirectoryUrl
+    return null
+  }
+  const refererUrlObject = new URL(referer)
+  refererUrlObject.searchParams.delete("hmr")
+  refererUrlObject.searchParams.delete("v")
+  const { pathname, search } = refererUrlObject
+  if (pathname.startsWith("/@fs/")) {
+    const fsRootRelativeUrl = pathname.slice("/@fs/".length)
+    return `file:///${fsRootRelativeUrl}${search}`
   }
   return moveUrl({
     url: referer,

package/src/omega/url_graph/url_graph_load.js

@@ -5,32 +5,31 @@ export const loadUrlGraph = async ({
   urlGraph,
   kitchen,
   startLoading,
+  writeGeneratedFiles,
   outDirectoryUrl,
   clientRuntimeCompat,
 }) => {
-  if (outDirectoryUrl) {
+  if (writeGeneratedFiles && outDirectoryUrl) {
     await ensureEmptyDirectory(outDirectoryUrl)
   }
   const promises = []
   const promiseMap = new Map()
-  const cook = ({ urlInfo, ...rest }) => {
+  const cook = (urlInfo, context) => {
     const promiseFromData = promiseMap.get(urlInfo)
     if (promiseFromData) return promiseFromData
-    const promise = _cook({
-      urlInfo,
+    const promise = _cook(urlInfo, {
       outDirectoryUrl,
       clientRuntimeCompat,
-      ...rest,
+      ...context,
     })
     promises.push(promise)
     promiseMap.set(urlInfo, promise)
     return promise
   }
-  const _cook = async ({ urlInfo, ...rest }) => {
-    await kitchen.cook({
-      urlInfo,
+  const _cook = async (urlInfo, context) => {
+    await kitchen.cook(urlInfo, {
       cookDuringCook: cook,
-      ...rest,
+      ...context,
     })
     const { references } = urlInfo
     references.forEach((reference) => {
@@ -46,10 +45,7 @@ export const loadUrlGraph = async ({
       const referencedUrlInfo = urlGraph.reuseOrCreateUrlInfo(
         reference.generatedUrl,
       )
-      cook({
-        reference,
-        urlInfo: referencedUrlInfo,
-      })
+      cook(referencedUrlInfo, { reference })
     })
   }
   startLoading(
@@ -61,10 +57,7 @@ export const loadUrlGraph = async ({
         specifier,
       })
       entryUrlInfo.data.isEntryPoint = true
-      cook({
-        reference: entryReference,
-        urlInfo: entryUrlInfo,
-      })
+      cook(entryUrlInfo, { reference: entryReference })
       return [entryReference, entryUrlInfo]
     },
   )

package/src/omega/url_graph/url_info_transformations.js

@@ -91,10 +91,7 @@ export const createUrlInfoTransformer = ({
         specifierColumn: column,
       })
       try {
-        await context.cook({
-          reference: sourcemapReference,
-          urlInfo: sourcemapUrlInfo,
-        })
+        await context.cook(sourcemapUrlInfo, { reference: sourcemapReference })
         const sourcemap = JSON.parse(sourcemapUrlInfo.content)
         urlInfo.sourcemap = normalizeSourcemap(urlInfo, sourcemap)
       } catch (e) {

package/src/omega/url_graph.js

@@ -1,4 +1,5 @@
 import { urlToRelativeUrl } from "@jsenv/filesystem"
+import { urlSpecifierEncoding } from "./url_specifier_encoding.js"
 
 export const createUrlGraph = ({
   clientFileChangeCallbackList,
@@ -23,13 +24,15 @@ export const createUrlGraph = ({
     urlInfos[url] = urlInfo
     return urlInfo
   }
-  const inferReference = (url, parentUrl) => {
+  const inferReference = (specifier, parentUrl) => {
     const parentUrlInfo = urlInfos[parentUrl]
     if (!parentUrlInfo) {
       return null
     }
     const firstReferenceOnThatUrl = parentUrlInfo.references.find(
-      (reference) => reference.url === url,
+      (reference) => {
+        return urlSpecifierEncoding.decode(reference) === specifier
+      },
     )
     return firstReferenceOnThatUrl
   }
@@ -192,5 +195,6 @@ const createUrlInfo = (url) => {
     sourcemap: null,
     sourcemapReference: null,
     timing: {},
+    responseHeaders: {},
   }
 }

package/src/omega/url_specifier_encoding.js

@@ -0,0 +1,59 @@
+export const urlSpecifierEncoding = {
+  encode: (reference) => {
+    const { generatedSpecifier } = reference
+    if (generatedSpecifier.then) {
+      return generatedSpecifier.then((value) => {
+        reference.generatedSpecifier = value
+        return urlSpecifierEncoding.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
+    },
+  },
+}