@jsenv/core 28.5.0 → 29.0.0

package/src/plugins/url_analysis/jsenv_plugin_url_analysis.js

@@ -11,7 +11,8 @@ export const jsenvPluginUrlAnalysis = ({
   include,
   supportedProtocols = ["file:", "data:", "virtual:", "http:", "https:"],
 }) => {
-  let getIncludeInfo = () => undefined
+  // eslint-disable-next-line no-unused-vars
+  let getIncludeInfo = (url) => undefined
   if (include) {
     const associations = URL_META.resolveAssociations(
       { include },
@@ -56,7 +57,6 @@ export const jsenvPluginUrlAnalysis = ({
       )
       if (protocolIsSupported) {
         reference.shouldHandle = true
-        return
       }
     },
     transformUrlContent: {

package/src/plugins/url_resolution/jsenv_plugin_url_resolution.js

@@ -1,34 +1,115 @@
-export const jsenvPluginUrlResolution = () => {
-  const urlResolver = (reference) => {
+/*
+ * This plugin is responsible to resolve urls except for a few cases:
+ * - A custom plugin implements a resolveUrl hook returning something
+ * - The reference.type is "filesystem" -> it is handled by jsenv_plugin_file_urls.js
+ *
+ * By default node esm resolution applies inside js modules
+ * and the rest uses the web standard url resolution (new URL):
+ * - "http_request"
+ * - "entry_point"
+ * - "js_import_export"
+ * - "link_href"
+ * - "script_src"
+ * - "a_href"
+ * - "iframe_src
+ * - "img_src"
+ * - "img_srcset"
+ * - "source_src"
+ * - "source_srcset"
+ * - "image_href"
+ * - "use_href"
+ * - "css_@import"
+ * - "css_url"
+ * - "sourcemap_comment"
+ * - "js_url_specifier"
+ * - "js_inline_content"
+ * - "webmanifest_icon_src"
+ * - "package_json"
+ */
+
+import { createNodeEsmResolver } from "./node_esm_resolver.js"
+
+export const jsenvPluginUrlResolution = ({
+  runtimeCompat,
+  clientMainFileUrl,
+  urlResolution,
+}) => {
+  const resolveUrlUsingWebResolution = (reference) => {
     return new URL(
       reference.specifier,
       reference.baseUrl || reference.parentUrl,
     ).href
   }
+
+  const resolvers = {}
+  Object.keys(urlResolution).forEach((referenceType) => {
+    const resolver = urlResolution[referenceType]
+    if (typeof resolver !== "object") {
+      throw new Error(
+        `Unexpected urlResolution configuration:
+"${referenceType}" resolution value must be an object, got ${resolver}`,
+      )
+    }
+    let { web, node_esm, ...rest } = resolver
+    const unexpectedKey = Object.keys(rest)[0]
+    if (unexpectedKey) {
+      throw new Error(
+        `Unexpected urlResolution configuration:
+"${referenceType}" resolution key must be "web" or "node_esm", found "${
+          Object.keys(rest)[0]
+        }"`,
+      )
+    }
+    if (node_esm === undefined) {
+      node_esm = referenceType === "js_import_export"
+    }
+    if (web === undefined) {
+      web = true
+    }
+    if (node_esm) {
+      if (node_esm === true) node_esm = {}
+      const { packageConditions } = node_esm
+      resolvers[referenceType] = createNodeEsmResolver({
+        runtimeCompat,
+        packageConditions,
+      })
+    } else if (web) {
+      resolvers[referenceType] = resolveUrlUsingWebResolution
+    }
+  })
+
+  if (!resolvers["js_import_export"]) {
+    resolvers.js_import_export = createNodeEsmResolver({ runtimeCompat })
+  }
+  if (!resolvers["*"]) {
+    resolvers["*"] = resolveUrlUsingWebResolution
+  }
+
   return {
     name: "jsenv:url_resolution",
     appliesDuring: "*",
-    resolveUrl: {
-      "http_request": urlResolver, // during dev
-      "entry_point": urlResolver, // during build
-      "link_href": urlResolver,
-      "script_src": urlResolver,
-      "a_href": urlResolver,
-      "iframe_src": urlResolver,
-      "img_src": urlResolver,
-      "img_srcset": urlResolver,
-      "source_src": urlResolver,
-      "source_srcset": urlResolver,
-      "image_href": urlResolver,
-      "use_href": urlResolver,
-      "css_@import": urlResolver,
-      "css_url": urlResolver,
-      "sourcemap_comment": urlResolver,
-      "js_import_export": urlResolver,
-      "js_url_specifier": urlResolver,
-      "js_inline_content": urlResolver,
-      "webmanifest_icon_src": urlResolver,
-      "package_json": urlResolver,
+    resolveUrl: (reference, context) => {
+      if (reference.specifier === "/") {
+        return String(clientMainFileUrl)
+      }
+      if (reference.specifier[0] === "/") {
+        return new URL(reference.specifier.slice(1), context.rootDirectoryUrl)
+          .href
+      }
+      const resolver = resolvers[reference.type] || resolvers["*"]
+      return resolver(reference, context)
+    },
+    // when specifier is prefixed by "file:///@ignore/"
+    // we return an empty js module (used by node esm)
+    fetchUrlContent: (urlInfo) => {
+      if (urlInfo.url.startsWith("file:///@ignore/")) {
+        return {
+          content: "export default {}",
+          contentType: "text/javascript",
+          type: "js_module",
+        }
+      }
+      return null
     },
   }
 }

package/src/plugins/url_resolution/node_esm_resolver.js

@@ -0,0 +1,110 @@
+/*
+ * - should I restore eventual search params lost during node esm resolution
+ * - what about symlinks?
+ *   It feels like I should apply symlink (when we don't want to preserve them)
+ *   once a file:/// url is found, regardless
+ *   if that comes from node resolution or anything else (not even magic resolution)
+ *   it should likely be an other plugin happening after the others
+ */
+
+import { readFileSync } from "node:fs"
+import { bufferToEtag } from "@jsenv/filesystem"
+import {
+  applyNodeEsmResolution,
+  readCustomConditionsFromProcessArgs,
+  defaultLookupPackageScope,
+  defaultReadPackageJson,
+} from "@jsenv/node-esm-resolution"
+
+export const createNodeEsmResolver = ({ runtimeCompat, packageConditions }) => {
+  const nodeRuntimeEnabled = Object.keys(runtimeCompat).includes("node")
+  // https://nodejs.org/api/esm.html#resolver-algorithm-specification
+  packageConditions = packageConditions || [
+    ...readCustomConditionsFromProcessArgs(),
+    nodeRuntimeEnabled ? "node" : "browser",
+    "import",
+  ]
+
+  return (reference, context) => {
+    const { parentUrl, specifier } = reference
+    const { url, type, packageUrl } = applyNodeEsmResolution({
+      conditions: packageConditions,
+      parentUrl,
+      specifier,
+    })
+    if (context.scenarios.dev) {
+      const dependsOnPackageJson =
+        type !== "relative_specifier" &&
+        type !== "absolute_specifier" &&
+        type !== "node_builtin_specifier"
+      if (dependsOnPackageJson) {
+        // this reference depends on package.json and node_modules
+        // to be resolved. Each file using this specifier
+        // must be invalidated when corresponding package.json changes
+        addRelationshipWithPackageJson({
+          reference,
+          context,
+          packageJsonUrl: `${packageUrl}package.json`,
+          field: type.startsWith("field:")
+            ? `#${type.slice("field:".length)}`
+            : "",
+        })
+      }
+    }
+    if (context.scenarios.dev) {
+      // without this check a file inside a project without package.json
+      // could be considered as a node module if there is a ancestor package.json
+      // but we want to version only node modules
+      if (url.includes("/node_modules/")) {
+        const packageDirectoryUrl = defaultLookupPackageScope(url)
+        if (
+          packageDirectoryUrl &&
+          packageDirectoryUrl !== context.rootDirectoryUrl
+        ) {
+          const packageVersion =
+            defaultReadPackageJson(packageDirectoryUrl).version
+          // package version can be null, see https://github.com/babel/babel/blob/2ce56e832c2dd7a7ed92c89028ba929f874c2f5c/packages/babel-runtime/helpers/esm/package.json#L2
+          if (packageVersion) {
+            addRelationshipWithPackageJson({
+              reference,
+              context,
+              packageJsonUrl: `${packageDirectoryUrl}package.json`,
+              field: "version",
+              hasVersioningEffect: true,
+            })
+          }
+          reference.version = packageVersion
+        }
+      }
+    }
+    return url
+  }
+}
+
+const addRelationshipWithPackageJson = ({
+  context,
+  packageJsonUrl,
+  field,
+  hasVersioningEffect = false,
+}) => {
+  const referenceFound = context.referenceUtils.find(
+    (ref) => ref.type === "package_json" && ref.subtype === field,
+  )
+  if (referenceFound) {
+    return
+  }
+  const [, packageJsonUrlInfo] = context.referenceUtils.inject({
+    type: "package_json",
+    subtype: field,
+    specifier: packageJsonUrl,
+    isImplicit: true,
+    hasVersioningEffect,
+  })
+  if (packageJsonUrlInfo.type === undefined) {
+    const packageJsonContentAsBuffer = readFileSync(new URL(packageJsonUrl))
+    packageJsonUrlInfo.type = "json"
+    packageJsonUrlInfo.content = String(packageJsonContentAsBuffer)
+    packageJsonUrlInfo.originalContentEtag = packageJsonUrlInfo.contentEtag =
+      bufferToEtag(packageJsonContentAsBuffer)
+  }
+}

package/src/plugins/url_version/jsenv_plugin_url_version.js

@@ -9,19 +9,24 @@ export const jsenvPluginUrlVersion = () => {
       // this goal is achieved when we reach this part of the code
       // We get rid of this params so that urlGraph and other parts of the code
       // recognize the url (it is not considered as a different url)
-      const urlObject = new URL(reference.url)
-      urlObject.searchParams.delete("v")
-      return urlObject.href
+      const version = reference.searchParams.get("v")
+      if (version) {
+        const urlObject = new URL(reference.url)
+        urlObject.searchParams.delete("v")
+        reference.version = version
+        return urlObject.href
+      }
+      return null
     },
     transformUrlSearchParams: (reference) => {
-      if (!reference.data.version) {
+      if (!reference.version) {
         return null
       }
       if (reference.searchParams.has("v")) {
         return null
       }
       return {
-        v: reference.data.version,
+        v: reference.version,
       }
     },
   }

package/src/plugins/leading_slash/jsenv_plugin_leading_slash.js

@@ -1,13 +0,0 @@
-export const jsenvPluginLeadingSlash = () => {
-  return {
-    name: "jsenv:leading_slash",
-    appliesDuring: "*",
-    resolveUrl: (reference, context) => {
-      if (reference.specifier[0] !== "/") {
-        return null
-      }
-      return new URL(reference.specifier.slice(1), context.rootDirectoryUrl)
-        .href
-    },
-  }
-}

package/src/plugins/node_esm_resolution/jsenv_plugin_node_esm_resolution.js

@@ -1,148 +0,0 @@
-/*
- * - should I restore eventual search params lost during node esm resolution
- * - what about symlinks?
- *   It feels like I should apply symlink (when we don't want to preserve them)
- *   once a file:/// url is found, regardless
- *   if that comes from node resolution or anything else (not even magic resolution)
- *   it should likely be an other plugin happening after the others
- */
-
-import { readFileSync } from "node:fs"
-import { bufferToEtag } from "@jsenv/filesystem"
-import {
-  applyNodeEsmResolution,
-  defaultLookupPackageScope,
-  defaultReadPackageJson,
-  readCustomConditionsFromProcessArgs,
-} from "@jsenv/node-esm-resolution"
-
-export const jsenvPluginNodeEsmResolution = ({ packageConditions }) => {
-  const addRelationshipWithPackageJson = ({
-    context,
-    packageJsonUrl,
-    field,
-    hasVersioningEffect = false,
-  }) => {
-    const referenceFound = context.referenceUtils.find(
-      (ref) => ref.type === "package_json" && ref.subtype === field,
-    )
-    if (referenceFound) {
-      return
-    }
-    const [, packageJsonUrlInfo] = context.referenceUtils.inject({
-      type: "package_json",
-      subtype: field,
-      specifier: packageJsonUrl,
-      isImplicit: true,
-      hasVersioningEffect,
-    })
-    if (packageJsonUrlInfo.type === undefined) {
-      const packageJsonContentAsBuffer = readFileSync(new URL(packageJsonUrl))
-      packageJsonUrlInfo.type = "json"
-      packageJsonUrlInfo.content = String(packageJsonContentAsBuffer)
-      packageJsonUrlInfo.originalContentEtag = packageJsonUrlInfo.contentEtag =
-        bufferToEtag(packageJsonContentAsBuffer)
-    }
-  }
-
-  return {
-    name: "jsenv:node_esm_resolution",
-    appliesDuring: "*",
-    init: (context) => {
-      const nodeRuntimeEnabled = Object.keys(context.runtimeCompat).includes(
-        "node",
-      )
-      // https://nodejs.org/api/esm.html#resolver-algorithm-specification
-      packageConditions = packageConditions || [
-        ...readCustomConditionsFromProcessArgs(),
-        nodeRuntimeEnabled ? "node" : "browser",
-        "import",
-      ]
-    },
-    resolveUrl: {
-      js_import_export: (reference, context) => {
-        const { parentUrl, specifier } = reference
-        const { url, type, packageUrl } = applyNodeEsmResolution({
-          conditions: packageConditions,
-          parentUrl,
-          specifier,
-        })
-        if (context.scenarios.dev) {
-          const dependsOnPackageJson =
-            type !== "relative_specifier" &&
-            type !== "absolute_specifier" &&
-            type !== "node_builtin_specifier"
-          if (dependsOnPackageJson) {
-            // this reference depends on package.json and node_modules
-            // to be resolved. Each file using this specifier
-            // must be invalidated when corresponding package.json changes
-            addRelationshipWithPackageJson({
-              reference,
-              context,
-              packageJsonUrl: `${packageUrl}package.json`,
-              field: type.startsWith("field:")
-                ? `#${type.slice("field:".length)}`
-                : "",
-            })
-          }
-        }
-        return url
-      },
-    },
-    transformUrlSearchParams: (reference, context) => {
-      if (reference.type === "package_json") {
-        return null
-      }
-      if (context.scenarios.build) {
-        return null
-      }
-      if (!reference.url.startsWith("file:")) {
-        return null
-      }
-      // without this check a file inside a project without package.json
-      // could be considered as a node module if there is a ancestor package.json
-      // but we want to version only node modules
-      if (!reference.url.includes("/node_modules/")) {
-        return null
-      }
-      if (reference.searchParams.has("v")) {
-        return null
-      }
-      const packageDirectoryUrl = defaultLookupPackageScope(reference.url)
-      if (!packageDirectoryUrl) {
-        return null
-      }
-      if (packageDirectoryUrl === context.rootDirectoryUrl) {
-        return null
-      }
-      // there is a dependency between this file and the package.json version field
-      const packageVersion = defaultReadPackageJson(packageDirectoryUrl).version
-      if (!packageVersion) {
-        // example where it happens: https://github.com/babel/babel/blob/2ce56e832c2dd7a7ed92c89028ba929f874c2f5c/packages/babel-runtime/helpers/esm/package.json#L2
-        return null
-      }
-      if (reference.type === "js_import_export") {
-        addRelationshipWithPackageJson({
-          reference,
-          context,
-          packageJsonUrl: `${packageDirectoryUrl}package.json`,
-          field: "version",
-          hasVersioningEffect: true,
-        })
-      }
-      return {
-        v: packageVersion,
-      }
-    },
-    fetchUrlContent: (urlInfo) => {
-      if (urlInfo.url.startsWith("file:///@ignore/")) {
-        return {
-          content: "export default {}",
-          contentType: "text/javascript",
-          type: "js_module",
-        }
-      }
-      return null
-    },
-  }
-}