@jsenv/core 27.0.0-alpha.12 → 27.0.0-alpha.13

package/src/plugins/file_urls/jsenv_plugin_file_urls.js

@@ -0,0 +1,66 @@
+import { readFileSync } from "node:fs"
+import { urlIsInsideOf, urlToRelativeUrl } from "@jsenv/filesystem"
+
+import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
+
+export const jsenvPluginFileUrls = () => {
+  return [jsenvPluginResolveAbsoluteFileUrls(), jsenvPluginFetchFileUrls()]
+}
+
+const jsenvPluginResolveAbsoluteFileUrls = () => {
+  return {
+    name: "jsenv:resolve_absolute_file_urls",
+    appliesDuring: {
+      // during dev and test it's a browser running the code
+      // so absolute file urls needs to be relativized
+      dev: true,
+      test: true,
+      // during build it's fine to use file:// urls
+      build: false,
+    },
+    resolveUrl: (reference) => {
+      if (!reference.specifier.startsWith("/@fs/")) {
+        return null
+      }
+      const fsRootRelativeUrl = reference.specifier.slice("/@fs/".length)
+      return `file:///${fsRootRelativeUrl}`
+    },
+    formatUrl: (reference, context) => {
+      if (!reference.generatedUrl.startsWith("file:")) {
+        return null
+      }
+      if (urlIsInsideOf(reference.generatedUrl, context.rootDirectoryUrl)) {
+        return `/${urlToRelativeUrl(
+          reference.generatedUrl,
+          context.rootDirectoryUrl,
+        )}`
+      }
+      return `/@fs/${reference.generatedUrl.slice("file:///".length)}`
+    },
+  }
+}
+
+const jsenvPluginFetchFileUrls = () => {
+  return {
+    name: "jsenv:fetch_file_urls",
+    appliesDuring: "*",
+    fetchUrlContent: (urlInfo) => {
+      if (!urlInfo.url.startsWith("file:")) {
+        return null
+      }
+      const urlObject = new URL(urlInfo.url)
+      const fileBuffer = readFileSync(urlObject)
+      const contentType = CONTENT_TYPE.fromUrlExtension(urlInfo.url)
+      if (CONTENT_TYPE.isTextual(contentType)) {
+        return {
+          contentType,
+          content: String(fileBuffer),
+        }
+      }
+      return {
+        contentType,
+        content: fileBuffer,
+      }
+    },
+  }
+}

package/src/{omega/core_plugins → plugins}/filesystem_magic/jsenv_plugin_filesystem_magic.js

@@ -13,12 +13,12 @@ export const jsenvPluginFileSystemMagic = ({
   return {
     name: "jsenv:filesystem_magic",
     appliesDuring: "*",
-    normalize: ({ parentUrl, url }) => {
+    normalizeUrl: (reference) => {
       // http, https, data, about, etc
-      if (!url.startsWith("file:")) {
+      if (!reference.url.startsWith("file:")) {
         return null
       }
-      const urlObject = new URL(url)
+      const urlObject = new URL(reference.url)
       const { search, hash } = urlObject
       urlObject.search = ""
       urlObject.hash = ""
@@ -26,7 +26,10 @@ export const jsenvPluginFileSystemMagic = ({
         urlObject.href,
         {
           magicDirectoryIndex,
-          magicExtensions: getExtensionsToTry(magicExtensions, parentUrl),
+          magicExtensions: getExtensionsToTry(
+            magicExtensions,
+            reference.parentUrl,
+          ),
         },
       )
       if (!filesystemResolution.found) {

package/src/{omega/core_plugins → plugins}/html_supervisor/client/html_supervisor_installer.js

@@ -89,7 +89,6 @@ export const installHtmlSupervisor = ({ logs, measurePerf }) => {
         onExecutionSettled(src, executionResult)
         if (logs) {
           console.log(`${type} load ended`)
-
           console.groupEnd()
         }
       },
@@ -120,7 +119,9 @@ export const installHtmlSupervisor = ({ logs, measurePerf }) => {
             console.error(error)
           }
         }
-        console.groupEnd()
+        if (logs) {
+          console.groupEnd()
+        }
       },
     )
   }

package/src/{omega/core_plugins → plugins}/html_supervisor/jsenv_plugin_html_supervisor.js

@@ -2,27 +2,21 @@
  * Things happening here
  * - html supervisor module injection
  * - scripts are wrapped to be supervised
- *
- * TODO:
- *  - if ressource is referenced by ressource hint we should do sthing?
- *   I think so when we inject ?js_classic
  */
 
-import { injectQueryParams } from "@jsenv/utils/urls/url_utils.js"
 import {
   parseHtmlString,
   stringifyHtmlAst,
   visitHtmlAst,
   getHtmlNodeAttributeByName,
   removeHtmlNodeAttributeByName,
-  setHtmlNodeText,
-  assignHtmlNodeAttributes,
   parseScriptNode,
   injectScriptAsEarlyAsPossible,
   createHtmlNode,
   htmlNodePosition,
-  removeHtmlNodeText,
   getHtmlNodeTextNode,
+  removeHtmlNodeText,
+  setHtmlNodeGeneratedText,
 } from "@jsenv/utils/html_ast/html_ast.js"
 import { generateInlineContentUrl } from "@jsenv/utils/urls/inline_content_url_generator.js"
 
@@ -45,7 +39,7 @@ export const jsenvPluginHtmlSupervisor = ({
       dev: true,
       test: true,
     },
-    transform: {
+    transformUrlContent: {
       html: ({ url, content }, { referenceUtils }) => {
         const htmlAst = parseHtmlString(content)
         const scriptsToSupervise = []
@@ -64,27 +58,22 @@ export const jsenvPluginHtmlSupervisor = ({
             lineEnd,
             columnEnd,
           })
-          if (scriptCategory === "classic") {
-            inlineScriptUrl = injectQueryParams(inlineScriptUrl, {
-              js_classic: "",
-            })
-          }
           const [inlineScriptReference] = referenceUtils.foundInline({
             type: "script_src",
+            expectedType: { classic: "js_classic", module: "js_module" }[
+              scriptCategory
+            ],
             line: line - 1,
             column,
-            isOriginal,
+            isOriginalPosition: isOriginal,
             specifier: inlineScriptUrl,
-            contentType: "application/javascript",
+            contentType: "text/javascript",
             content: textNode.value,
           })
-          assignHtmlNodeAttributes(node, {
-            "src": inlineScriptReference.generatedSpecifier,
-            "src-generated-from-inline-content": "",
-          })
           removeHtmlNodeText(node)
           scriptsToSupervise.push({
             node,
+            isInline: true,
             type: scriptCategory,
             src: inlineScriptReference.generatedSpecifier,
           })
@@ -105,6 +94,7 @@ export const jsenvPluginHtmlSupervisor = ({
           const crossorigin = crossoriginAttribute
             ? crossoriginAttribute.value
             : undefined
+          removeHtmlNodeAttributeByName(node, "src")
           scriptsToSupervise.push({
             node,
             type: scriptCategory,
@@ -151,6 +141,7 @@ export const jsenvPluginHtmlSupervisor = ({
         }
         const [htmlSupervisorInstallerFileReference] = referenceUtils.inject({
           type: "js_import_export",
+          expectedType: "js_module",
           specifier: htmlSupervisorInstallerFileUrl,
         })
         injectScriptAsEarlyAsPossible(
@@ -159,25 +150,24 @@ export const jsenvPluginHtmlSupervisor = ({
             "tagName": "script",
             "type": "module",
             "textContent": `
-import { installHtmlSupervisor } from ${
-              htmlSupervisorInstallerFileReference.generatedSpecifier
-            }
-installHtmlSupervisor(${JSON.stringify(
-              {
-                logs,
-                measurePerf,
-              },
-              null,
-              "  ",
-            )})`,
+      import { installHtmlSupervisor } from ${
+        htmlSupervisorInstallerFileReference.generatedSpecifier
+      }
+      installHtmlSupervisor(${JSON.stringify(
+        {
+          logs,
+          measurePerf,
+        },
+        null,
+        "        ",
+      )})`,
             "injected-by": "jsenv:html_supervisor",
           }),
         )
         const [htmlSupervisorSetupFileReference] = referenceUtils.inject({
           type: "script_src",
-          specifier: injectQueryParams(htmlSupervisorSetupFileUrl, {
-            js_classic: "",
-          }),
+          expectedType: "js_classic",
+          specifier: htmlSupervisorSetupFileUrl,
         })
         injectScriptAsEarlyAsPossible(
           htmlAst,
@@ -188,14 +178,9 @@ installHtmlSupervisor(${JSON.stringify(
           }),
         )
         scriptsToSupervise.forEach(
-          ({ node, type, src, integrity, crossorigin }) => {
-            removeHtmlNodeAttributeByName(node, "src")
-            assignHtmlNodeAttributes(node, {
-              "content-src": src,
-            })
-            setHtmlNodeText(
-              node,
-              generateCodeToSuperviseScript({
+          ({ node, isInline, type, src, integrity, crossorigin }) => {
+            setHtmlNodeGeneratedText(node, {
+              generatedText: generateCodeToSuperviseScript({
                 type,
                 src,
                 integrity,
@@ -203,7 +188,10 @@ installHtmlSupervisor(${JSON.stringify(
                 htmlSupervisorInstallerSpecifier:
                   htmlSupervisorInstallerFileReference.generatedSpecifier,
               }),
-            )
+              generatedBy: "jsenv:html_supervisor",
+              generatedFromSrc: src,
+              generatedFromInlineContent: isInline,
+            })
           },
         )
         const htmlModified = stringifyHtmlAst(htmlAst)
@@ -226,8 +214,12 @@ const generateCodeToSuperviseScript = ({
 }) => {
   const paramsAsJson = JSON.stringify({ src, integrity, crossorigin })
   if (type === "module") {
-    return `import { superviseScriptTypeModule } from ${htmlSupervisorInstallerSpecifier}
-superviseScriptTypeModule(${paramsAsJson})`
+    return `
+      import { superviseScriptTypeModule } from ${htmlSupervisorInstallerSpecifier}
+      superviseScriptTypeModule(${paramsAsJson})
+`
   }
-  return `window.__html_supervisor__.superviseScript(${paramsAsJson})`
+  return `
+      window.__html_supervisor__.superviseScript(${paramsAsJson})
+`
 }

package/src/plugins/http_urls/jsenv_plugin_http_urls.js

@@ -0,0 +1,12 @@
+export const jsenvPluginHttpUrls = () => {
+  return {
+    name: "jsenv:http_urls",
+    appliesDuring: "*",
+    fetchUrlContent: (urlInfo) => {
+      if (urlInfo.url.startsWith("http") || urlInfo.url.startsWith("https")) {
+        return { external: true }
+      }
+      return null
+    },
+  }
+}

package/src/{omega/core_plugins → plugins}/import_meta_scenarios/jsenv_plugin_import_meta_scenarios.js

@@ -12,18 +12,15 @@
 import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
 import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
 
-import { collectProgramImportMetas } from "@jsenv/utils/js_ast/program_import_metas.js"
-
 export const jsenvPluginImportMetaScenarios = () => {
   return {
     name: "jsenv:import_meta_scenario",
     appliesDuring: "*",
-    transform: {
-      js_module: async ({ url, content }, { scenario }) => {
+    transformUrlContent: {
+      js_module: async (urlInfo, { scenario }) => {
         const { metadata } = await applyBabelPlugins({
           babelPlugins: [babelPluginMetadataImportMetaScenarios],
-          url,
-          content,
+          urlInfo,
         })
         const { dev = [], test = [], build = [] } = metadata.importMetaScenarios
         const replacements = []
@@ -59,7 +56,7 @@ export const jsenvPluginImportMetaScenarios = () => {
             replace(path, "true")
           })
         }
-        const magicSource = createMagicSource(content)
+        const magicSource = createMagicSource(urlInfo.content)
         replacements.forEach(({ path, value }) => {
           magicSource.replace({
             start: path.node.start,
@@ -78,7 +75,28 @@ const babelPluginMetadataImportMetaScenarios = () => {
     name: "metadata-import-meta-scenarios",
     visitor: {
       Program(programPath, state) {
-        const importMetas = collectProgramImportMetas(programPath)
+        const importMetas = {}
+        programPath.traverse({
+          MemberExpression(path) {
+            const { node } = path
+            const { object } = node
+            if (object.type !== "MetaProperty") {
+              return
+            }
+            const { property: objectProperty } = object
+            if (objectProperty.name !== "meta") {
+              return
+            }
+            const { property } = node
+            const { name } = property
+            const importMetaPaths = importMetas[name]
+            if (importMetaPaths) {
+              importMetaPaths.push(path)
+            } else {
+              importMetas[name] = [path]
+            }
+          },
+        })
         state.file.metadata.importMetaScenarios = {
           dev: importMetas.dev,
           test: importMetas.test,

package/src/plugins/import_meta_url/client/import_meta_url_browser.js

@@ -0,0 +1,52 @@
+const getCurrentScriptSrc = () => {
+  const { currentScript } = document
+  if (currentScript) return currentScript.src
+
+  // https://github.com/amiller-gh/currentScript-polyfill
+
+  const scripts = Array.prototype.slice.call(
+    document.getElementsByTagName("script"),
+  )
+
+  const readyScript = scripts.find((script) => {
+    return script.readyState === "interactive"
+  })
+  if (readyScript) return readyScript
+
+  try {
+    throw new Error()
+  } catch (err) {
+    // Find the second match for the "at" string to get file src url from stack.
+    // Specifically works with the format of stack traces in IE.
+    const stackDetails = /.*at [^(]*\((.*):(.+):(.+)\)$/gi.exec(err.stack)
+    const scriptLocation = (stackDetails || [false])[1]
+    const line = (stackDetails || [false])[2]
+    const currentLocation = document.location.href.replace(
+      document.location.hash,
+      "",
+    )
+
+    if (scriptLocation === currentLocation) {
+      const source = document.documentElement.outerHTML
+      const codeRegExp = new RegExp(
+        `(?:[^\\n]+?\\n){0,${
+          line - 2
+        }}[^<]*<script>([\\d\\D]*?)<\\/script>[\\d\\D]*`,
+        "i",
+      )
+      const code = source.replace(codeRegExp, "$1").trim()
+
+      return scripts.find((script) => {
+        return script.innerHTML && script.innerHTML.trim() === code
+      })
+    }
+
+    return scripts.find((script) => {
+      return script.src === scriptLocation
+    })
+  }
+}
+
+const url = getCurrentScriptSrc()
+
+export default url

package/src/plugins/import_meta_url/client/import_meta_url_commonjs.mjs

@@ -0,0 +1,9 @@
+/* global __filename */
+
+const filenameContainsBackSlashes = __filename.indexOf("\\") > -1
+
+const url = filenameContainsBackSlashes
+  ? `file:///${__filename.replace(/\\/g, "/")}`
+  : `file://${__filename}`
+
+export default url

package/src/{omega/core_plugins → plugins}/importmap/jsenv_plugin_importmap.js

@@ -30,8 +30,7 @@ import {
   getHtmlNodeAttributeByName,
   htmlNodePosition,
   removeHtmlNodeAttributeByName,
-  setHtmlNodeText,
-  assignHtmlNodeAttributes,
+  setHtmlNodeGeneratedText,
   getHtmlNodeTextNode,
   removeHtmlNode,
 } from "@jsenv/utils/html_ast/html_ast.js"
@@ -59,16 +58,16 @@ export const jsenvPluginImportmap = () => {
   return {
     name: "jsenv:importmap",
     appliesDuring: "*",
-    resolve: {
-      js_import_export: ({ parentUrl, specifier }) => {
+    resolveUrl: {
+      js_import_export: (reference) => {
         if (!finalImportmap) {
           return null
         }
         try {
           let fromMapping = false
           const result = resolveImport({
-            specifier,
-            importer: parentUrl,
+            specifier: reference.specifier,
+            importer: reference.parentUrl,
             importMap: finalImportmap,
             onImportMapping: () => {
               fromMapping = true
@@ -91,12 +90,9 @@ export const jsenvPluginImportmap = () => {
         }
       },
     },
-    transform: {
-      html: async (
-        { url, content, references },
-        { scenario, cook, urlGraph, referenceUtils },
-      ) => {
-        const htmlAst = parseHtmlString(content)
+    transformUrlContent: {
+      html: async (htmlUrlInfo, context) => {
+        const htmlAst = parseHtmlString(htmlUrlInfo.content)
         const importmap = findNode(htmlAst, (node) => {
           if (node.nodeName !== "script") {
             return false
@@ -108,7 +104,7 @@ export const jsenvPluginImportmap = () => {
           return true
         })
         if (!importmap) {
-          onHtmlImportmapParsed(null, url)
+          onHtmlImportmapParsed(null, htmlUrlInfo.url)
           return null
         }
         const handleInlineImportmap = async (importmap, textNode) => {
@@ -117,7 +113,7 @@ export const jsenvPluginImportmap = () => {
               preferOriginal: true,
             })
           const inlineImportmapUrl = generateInlineContentUrl({
-            url,
+            url: htmlUrlInfo.url,
             extension: ".importmap",
             line,
             column,
@@ -125,21 +121,27 @@ export const jsenvPluginImportmap = () => {
             columnEnd,
           })
           const [inlineImportmapReference, inlineImportmapUrlInfo] =
-            referenceUtils.foundInline({
+            context.referenceUtils.foundInline({
               type: "script_src",
               line: line - 1,
               column,
-              isOriginal,
+              isOriginalPosition: isOriginal,
               specifier: inlineImportmapUrl,
               contentType: "application/importmap+json",
               content: textNode.value,
             })
-          await cook({
+          await context.cook({
             reference: inlineImportmapReference,
             urlInfo: inlineImportmapUrlInfo,
           })
-          setHtmlNodeText(importmap, inlineImportmapUrlInfo.content)
-          onHtmlImportmapParsed(JSON.parse(inlineImportmapUrlInfo.content), url)
+          setHtmlNodeGeneratedText(importmap, {
+            generatedText: inlineImportmapUrlInfo.content,
+            generatedBy: "jsenv:importmap",
+          })
+          onHtmlImportmapParsed(
+            JSON.parse(inlineImportmapUrlInfo.content),
+            htmlUrlInfo.url,
+          )
         }
         const handleImportmapWithSrc = async (importmap, src) => {
           // Browser would throw on remote importmap
@@ -147,35 +149,39 @@ export const jsenvPluginImportmap = () => {
           // We must precook the importmap to know its content and inline it into the HTML
           // In this situation the ref to the importmap was already discovered
           // when parsing the HTML
-          const importmapReference = references.find(
-            (reference) => reference.url === src,
+          const importmapReference =
+            context.referenceUtils.findByGeneratedSpecifier(src)
+          const importmapUrlInfo = context.urlGraph.getUrlInfo(
+            importmapReference.url,
           )
-          const importmapUrlInfo = urlGraph.getUrlInfo(importmapReference.url)
-          await cook({
+          await context.cook({
             reference: importmapReference,
             urlInfo: importmapUrlInfo,
           })
-          onHtmlImportmapParsed(JSON.parse(importmapUrlInfo.content), url)
+          onHtmlImportmapParsed(
+            JSON.parse(importmapUrlInfo.content),
+            htmlUrlInfo.url,
+          )
           removeHtmlNodeAttributeByName(importmap, "src")
-          assignHtmlNodeAttributes(importmap, {
-            "content-src": src,
-            "inlined-by": "jsenv:importmap",
+          setHtmlNodeGeneratedText(importmap, {
+            generatedText: importmapUrlInfo.content,
+            generatedBy: "jsenv:importmap",
+            generatedFromSrc: src,
           })
-          setHtmlNodeText(importmap, importmapUrlInfo.content)
 
           const { line, column, lineEnd, columnEnd, isOriginal } =
             htmlNodePosition.readNodePosition(importmap, {
               preferOriginal: true,
             })
           const inlineImportmapUrl = generateInlineContentUrl({
-            url,
+            url: htmlUrlInfo.url,
             extension: ".importmap",
             line,
             column,
             lineEnd,
             columnEnd,
           })
-          referenceUtils.becomesInline(importmapReference, {
+          context.referenceUtils.becomesInline(importmapReference, {
             line: line - 1,
             column,
             isOriginal,
@@ -200,7 +206,7 @@ export const jsenvPluginImportmap = () => {
         // by "formatReferencedUrl" making the importmap presence useless.
         // In dev/test we keep importmap into the HTML to see it even if useless
         // Duing build we get rid of it
-        if (scenario === "build") {
+        if (context.scenario === "build") {
           removeHtmlNode(importmap)
         }
         return {

package/src/{omega/core_plugins → plugins}/inject_globals/jsenv_plugin_inject_globals.js

@@ -1,4 +1,5 @@
 import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
+import { isWebWorkerUrlInfo } from "@jsenv/core/src/omega/web_workers.js"
 
 export const jsenvPluginInjectGlobals = (globals = {}) => {
   if (Object.keys(globals).length === 0) {
@@ -6,10 +7,7 @@ export const jsenvPluginInjectGlobals = (globals = {}) => {
   }
   const injectGlobals = (urlInfo) => {
     const magicSource = createMagicSource(urlInfo.content)
-    const globalName =
-      urlInfo.subtype === "worker" || urlInfo.subtype === "service_worker"
-        ? "self"
-        : "window"
+    const globalName = isWebWorkerUrlInfo(urlInfo) ? "self" : "window"
     magicSource.prepend(
       `Object.assign(${globalName}, ${JSON.stringify(globals, null, "  ")});`,
     )
@@ -19,9 +17,9 @@ export const jsenvPluginInjectGlobals = (globals = {}) => {
   return {
     name: "jsenv:inject_globals",
     appliesDuring: "*",
-    transform: {
-      js_module: injectGlobals,
+    transformUrlContent: {
       js_classic: injectGlobals,
+      js_module: injectGlobals,
     },
   }
 }