@jsenv/core 27.0.0-alpha.4 → 27.0.0-alpha.40

package/src/{omega/core_plugins → plugins}/commonjs_globals/jsenv_plugin_commonjs_globals.js

@@ -11,50 +11,63 @@ import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
 import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
 
 export const jsenvPluginCommonJsGlobals = () => {
+  const transformCommonJsGlobals = async (urlInfo, { scenario }) => {
+    if (
+      !urlInfo.content.includes("process.env.NODE_ENV") &&
+      !urlInfo.content.includes("__filename") &&
+      !urlInfo.content.includes("__dirname")
+    ) {
+      return null
+    }
+    const isJsModule = urlInfo.type === "js_module"
+    const replaceMap = {
+      "process.env.NODE_ENV": `("${
+        scenario === "dev" || scenario === "test" ? "dev" : "prod"
+      }")`,
+      "global": "globalThis",
+      "__filename": isJsModule
+        ? `import.meta.url.slice('file:///'.length)`
+        : `document.currentScript.src`,
+      "__dirname": isJsModule
+        ? `import.meta.url.slice('file:///'.length).replace(/[\\\/\\\\][^\\\/\\\\]*$/, '')`
+        : `new URL('./', document.currentScript.src).href`,
+    }
+    const { metadata } = await applyBabelPlugins({
+      babelPlugins: [
+        [
+          babelPluginMetadataExpressionPaths,
+          {
+            replaceMap,
+            allowConflictingReplacements: true,
+          },
+        ],
+      ],
+      urlInfo,
+    })
+    const { expressionPaths } = metadata
+    const keys = Object.keys(expressionPaths)
+    if (keys.length === 0) {
+      return null
+    }
+    const magicSource = createMagicSource(urlInfo.content)
+    keys.forEach((key) => {
+      expressionPaths[key].forEach((path) => {
+        magicSource.replace({
+          start: path.node.start,
+          end: path.node.end,
+          replacement: replaceMap[key],
+        })
+      })
+    })
+    return magicSource.toContentAndSourcemap()
+  }
+
   return {
     name: "jsenv:commonjs_globals",
     appliesDuring: "*",
-    transform: {
-      js_module: async ({ url, generatedUrl, content }, { scenario }) => {
-        const replaceMap = {
-          "process.env.NODE_ENV": `("${
-            scenario === "dev" || scenario === "test" ? "dev" : "prod"
-          }")`,
-          "global": "globalThis",
-          "__filename": `import.meta.url.slice('file:///'.length)`,
-          "__dirname": `import.meta.url.slice('file:///'.length).replace(/[\\\/\\\\][^\\\/\\\\]*$/, '')`,
-        }
-        const { metadata } = await applyBabelPlugins({
-          babelPlugins: [
-            [
-              babelPluginMetadataExpressionPaths,
-              {
-                replaceMap,
-                allowConflictingReplacements: true,
-              },
-            ],
-          ],
-          url,
-          generatedUrl,
-          content,
-        })
-        const { expressionPaths } = metadata
-        const keys = Object.keys(expressionPaths)
-        if (keys.length === 0) {
-          return null
-        }
-        const magicSource = createMagicSource(content)
-        keys.forEach((key) => {
-          expressionPaths[key].forEach((path) => {
-            magicSource.replace({
-              start: path.node.start,
-              end: path.node.end,
-              replacement: replaceMap[key],
-            })
-          })
-        })
-        return magicSource.toContentAndSourcemap()
-      },
+    transformUrlContent: {
+      js_classic: transformCommonJsGlobals,
+      js_module: transformCommonJsGlobals,
     },
   }
 }

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

@@ -6,19 +6,19 @@ import { urlToExtension } from "@jsenv/filesystem"
 import { applyFileSystemMagicResolution } from "@jsenv/node-esm-resolution"
 
 export const jsenvPluginFileSystemMagic = ({
-  magicExtensions = ["inherit"],
+  magicExtensions = ["inherit", ".js"],
   magicDirectoryIndex = true,
   preservesSymlink = true,
 } = {}) => {
   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,42 +2,41 @@
  * 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 { urlIsInsideOf } from "@jsenv/filesystem"
+
 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"
+import { jsenvRootDirectoryUrl } from "@jsenv/core/src/jsenv_root_directory_url.js"
 
 export const jsenvPluginHtmlSupervisor = ({
+  rootDirectoryUrl,
   logs = false,
   measurePerf = false,
-} = {}) => {
-  const htmlSupervisorSetupFileUrl = new URL(
-    "./client/html_supervisor_setup.js",
-    import.meta.url,
-  ).href
-  const htmlSupervisorInstallerFileUrl = new URL(
-    "./client/html_supervisor_installer.js",
-    import.meta.url,
-  ).href
+}) => {
+  const preferSourceFiles =
+    rootDirectoryUrl === jsenvRootDirectoryUrl ||
+    urlIsInsideOf(rootDirectoryUrl, jsenvRootDirectoryUrl)
+  const htmlSupervisorSetupFileUrl = preferSourceFiles
+    ? new URL("./client/html_supervisor_setup.js", import.meta.url).href
+    : new URL("./dist/html_supervisor_setup.js", jsenvRootDirectoryUrl)
+  const htmlSupervisorInstallerFileUrl = preferSourceFiles
+    ? new URL("./client/html_supervisor_installer.js", import.meta.url).href
+    : new URL("./dist/html_supervisor_installer.js", jsenvRootDirectoryUrl)
 
   return {
     name: "jsenv:html_supervisor",
@@ -45,7 +44,7 @@ export const jsenvPluginHtmlSupervisor = ({
       dev: true,
       test: true,
     },
-    transform: {
+    transformUrlContent: {
       html: ({ url, content }, { referenceUtils }) => {
         const htmlAst = parseHtmlString(content)
         const scriptsToSupervise = []
@@ -64,27 +63,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 +99,7 @@ export const jsenvPluginHtmlSupervisor = ({
           const crossorigin = crossoriginAttribute
             ? crossoriginAttribute.value
             : undefined
+          removeHtmlNodeAttributeByName(node, "src")
           scriptsToSupervise.push({
             node,
             type: scriptCategory,
@@ -151,6 +146,7 @@ export const jsenvPluginHtmlSupervisor = ({
         }
         const [htmlSupervisorInstallerFileReference] = referenceUtils.inject({
           type: "js_import_export",
+          expectedType: "js_module",
           specifier: htmlSupervisorInstallerFileUrl,
         })
         injectScriptAsEarlyAsPossible(
@@ -159,25 +155,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 +183,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 +193,10 @@ installHtmlSupervisor(${JSON.stringify(
                 htmlSupervisorInstallerSpecifier:
                   htmlSupervisorInstallerFileReference.generatedSpecifier,
               }),
-            )
+              generatedBy: "jsenv:html_supervisor",
+              generatedFromSrc: src,
+              generatedFromInlineContent: isInline,
+            })
           },
         )
         const htmlModified = stringifyHtmlAst(htmlAst)
@@ -226,8 +219,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/{dev/plugins/autoreload → plugins/import_meta_hot}/babel_plugin_metadata_import_meta_hot.js

@@ -16,13 +16,12 @@ export const babelPluginMetadataImportMetaHot = () => {
   }
 }
 const collectImportMetaProperties = (programPath) => {
-  let importMetaHotDetected = false
+  const importMetaHotPaths = []
   let hotDecline = false
   let hotAcceptSelf = false
   let hotAcceptDependencies = []
   programPath.traverse({
     MemberExpression(path) {
-      if (importMetaHotDetected) return
       const { node } = path
       const { object } = node
       if (object.type !== "MetaProperty") {
@@ -35,7 +34,7 @@ const collectImportMetaProperties = (programPath) => {
       const { property } = node
       const { name } = property
       if (name === "hot") {
-        importMetaHotDetected = true
+        importMetaHotPaths.push(path)
       }
     },
     CallExpression(path) {
@@ -64,7 +63,7 @@ const collectImportMetaProperties = (programPath) => {
               )
             }
             return {
-              specifierPath: firstArgPath.get(index),
+              specifierPath: firstArgPath.get(String(index)),
             }
           })
           return
@@ -79,7 +78,7 @@ const collectImportMetaProperties = (programPath) => {
     },
   })
   return {
-    importMetaHotDetected,
+    importMetaHotPaths,
     hotDecline,
     hotAcceptSelf,
     hotAcceptDependencies,

package/src/{dev/plugins/autoreload → plugins/import_meta_hot}/client/import_meta_hot.js

@@ -40,7 +40,9 @@ export const createImportMetaHot = (importMetaUrl) => {
         })
         return
       }
-      throw new Error(`invalid call to hot.accept()`)
+      throw new Error(
+        `invalid call to import.meta.hot.accept(), received ${firstArg}`,
+      )
     },
     dispose: (callback) => {
       addUrlMeta(url, {

package/src/{dev/plugins/autoreload → plugins/import_meta_hot}/html_hot_dependencies.js

@@ -53,7 +53,7 @@ export const collectHotDataFromHtmlAst = (htmlAst) => {
       })
       visitUrlSpecifierAttribute({
         node,
-        attributeName: "content-href",
+        attributeName: "generated-from-href",
         hotAccepted,
       })
     }
@@ -65,7 +65,7 @@ export const collectHotDataFromHtmlAst = (htmlAst) => {
       })
       visitUrlSpecifierAttribute({
         node,
-        attributeName: "content-src",
+        attributeName: "generated-from-src",
         hotAccepted,
       })
     }

package/src/plugins/import_meta_hot/jsenv_plugin_import_meta_hot.js

@@ -0,0 +1,101 @@
+import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
+import { parseHtmlString } from "@jsenv/utils/html_ast/html_ast.js"
+import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
+
+import { collectHotDataFromHtmlAst } from "./html_hot_dependencies.js"
+import { babelPluginMetadataImportMetaHot } from "./babel_plugin_metadata_import_meta_hot.js"
+
+const importMetaHotClientFileUrl = new URL(
+  "./client/import_meta_hot.js",
+  import.meta.url,
+).href
+
+export const jsenvPluginImportMetaHot = () => {
+  return {
+    name: "jsenv:import_meta_hot",
+    appliesDuring: "*",
+    transformUrlContent: {
+      html: (htmlUrlInfo, context) => {
+        // during build we don't really care to parse html hot dependencies
+        if (context.scenario === "build") {
+          return
+        }
+        const htmlAst = parseHtmlString(htmlUrlInfo.content)
+        const { hotReferences } = collectHotDataFromHtmlAst(htmlAst)
+        htmlUrlInfo.data.hotDecline = false
+        htmlUrlInfo.data.hotAcceptSelf = false
+        htmlUrlInfo.data.hotAcceptDependencies = hotReferences.map(
+          ({ type, specifier }) => {
+            const [reference] = context.referenceUtils.found({
+              type,
+              specifier,
+            })
+            return reference.url
+          },
+        )
+      },
+      css: (cssUrlInfo) => {
+        cssUrlInfo.data.hotDecline = false
+        cssUrlInfo.data.hotAcceptSelf = false
+        cssUrlInfo.data.hotAcceptDependencies = []
+      },
+      js_module: async (urlInfo, context) => {
+        if (!urlInfo.content.includes("import.meta.hot")) {
+          return null
+        }
+        const { metadata } = await applyBabelPlugins({
+          babelPlugins: [babelPluginMetadataImportMetaHot],
+          urlInfo,
+        })
+        const {
+          importMetaHotPaths,
+          hotDecline,
+          hotAcceptSelf,
+          hotAcceptDependencies,
+        } = metadata
+        urlInfo.data.hotDecline = hotDecline
+        urlInfo.data.hotAcceptSelf = hotAcceptSelf
+        urlInfo.data.hotAcceptDependencies = hotAcceptDependencies
+        if (importMetaHotPaths.length === 0) {
+          return null
+        }
+        if (context.scenario === "build") {
+          return removeImportMetaHots(urlInfo, importMetaHotPaths)
+        }
+        return injectImportMetaHot(urlInfo, context)
+      },
+    },
+  }
+}
+
+const removeImportMetaHots = (urlInfo, importMetaHotPaths) => {
+  const magicSource = createMagicSource(urlInfo.content)
+  importMetaHotPaths.forEach((path) => {
+    magicSource.replace({
+      start: path.node.start,
+      end: path.node.end,
+      replacement: "undefined",
+    })
+  })
+  return magicSource.toContentAndSourcemap()
+}
+
+// For some reason using magic source here produce
+// better sourcemap than doing the equivalent with babel
+// I suspect it's because I was doing injectAstAfterImport(programPath, ast.program.body[0])
+// which is likely not well supported by babel
+const injectImportMetaHot = (urlInfo, context) => {
+  const [importMetaHotClientFileReference] = context.referenceUtils.inject({
+    parentUrl: urlInfo.url,
+    type: "js_import_export",
+    expectedType: "js_module",
+    specifier: importMetaHotClientFileUrl,
+  })
+  const magicSource = createMagicSource(urlInfo.content)
+  magicSource.prepend(
+    `import { createImportMetaHot } from ${importMetaHotClientFileReference.generatedSpecifier}
+import.meta.hot = createImportMetaHot(import.meta.url)
+`,
+  )
+  return magicSource.toContentAndSourcemap()
+}