@jsenv/core 35.0.3 → 35.0.4

package/src/plugins/url_resolution/jsenv_plugin_url_resolution.js

@@ -29,7 +29,7 @@
  * - "package_json"
  */
 
-import { createNodeEsmResolver } from "./node_esm_resolver.js"
+import { createNodeEsmResolver } from "./node_esm_resolver.js";
 
 export const jsenvPluginUrlResolution = ({
   runtimeCompat,
@@ -42,62 +42,62 @@ export const jsenvPluginUrlResolution = ({
       // baseUrl happens second argument to new URL() is different from
       // import.meta.url or document.currentScript.src
       reference.baseUrl || reference.parentUrl,
-    ).href
-  }
+    ).href;
+  };
 
-  const resolvers = {}
+  const resolvers = {};
   Object.keys(urlResolution).forEach((urlType) => {
-    const resolver = urlResolution[urlType]
+    const resolver = urlResolution[urlType];
     if (typeof resolver !== "object") {
       throw new Error(
         `urlResolution values must be objects, got ${resolver} on "${urlType}"`,
-      )
+      );
     }
-    let { web, node_esm, ...rest } = resolver
-    const unexpectedKeys = Object.keys(rest)
+    let { web, node_esm, ...rest } = resolver;
+    const unexpectedKeys = Object.keys(rest);
     if (unexpectedKeys.length) {
       throw new TypeError(
         `${unexpectedKeys.join(
           ",",
         )}: there is no such configuration on "${urlType}"`,
-      )
+      );
     }
     if (node_esm === undefined) {
-      node_esm = urlType === "js_import"
+      node_esm = urlType === "js_import";
     }
     if (web === undefined) {
-      web = true
+      web = true;
     }
     if (node_esm) {
-      if (node_esm === true) node_esm = {}
-      const { packageConditions, preservesSymlink } = node_esm
+      if (node_esm === true) node_esm = {};
+      const { packageConditions, preservesSymlink } = node_esm;
       resolvers[urlType] = createNodeEsmResolver({
         runtimeCompat,
         packageConditions,
         preservesSymlink,
-      })
+      });
     } else if (web) {
-      resolvers[urlType] = resolveUrlUsingWebResolution
+      resolvers[urlType] = resolveUrlUsingWebResolution;
     }
-  })
+  });
 
   const nodeEsmResolverDefault = createNodeEsmResolver({
     runtimeCompat,
     preservesSymlink: true,
-  })
+  });
   if (!resolvers.js_module) {
-    resolvers.js_module = nodeEsmResolverDefault
+    resolvers.js_module = nodeEsmResolverDefault;
   }
   if (!resolvers.js_classic) {
     resolvers.js_classic = (reference, context) => {
       if (reference.subtype === "self_import_scripts_arg") {
-        return nodeEsmResolverDefault(reference, context)
+        return nodeEsmResolverDefault(reference, context);
       }
-      return resolveUrlUsingWebResolution(reference, context)
-    }
+      return resolveUrlUsingWebResolution(reference, context);
+    };
   }
   if (!resolvers["*"]) {
-    resolvers["*"] = resolveUrlUsingWebResolution
+    resolvers["*"] = resolveUrlUsingWebResolution;
   }
 
   return {
@@ -105,24 +105,24 @@ export const jsenvPluginUrlResolution = ({
     appliesDuring: "*",
     resolveUrl: (reference, context) => {
       if (reference.specifier === "/") {
-        return String(defaultFileUrl)
+        return String(defaultFileUrl);
       }
       if (reference.specifier[0] === "/") {
         return new URL(reference.specifier.slice(1), context.rootDirectoryUrl)
-          .href
+          .href;
       }
       if (reference.type === "sourcemap_comment") {
-        return resolveUrlUsingWebResolution(reference, context)
+        return resolveUrlUsingWebResolution(reference, context);
       }
-      let urlType
+      let urlType;
       if (reference.injected) {
-        urlType = reference.expectedType
+        urlType = reference.expectedType;
       } else {
-        const parentUrlInfo = context.urlGraph.getUrlInfo(reference.parentUrl)
-        urlType = parentUrlInfo ? parentUrlInfo.type : "entry_point"
+        const parentUrlInfo = context.urlGraph.getUrlInfo(reference.parentUrl);
+        urlType = parentUrlInfo ? parentUrlInfo.type : "entry_point";
       }
-      const resolver = resolvers[urlType] || resolvers["*"]
-      return resolver(reference, context)
+      const resolver = resolvers[urlType] || resolvers["*"];
+      return resolver(reference, context);
     },
     // when specifier is prefixed by "file:///@ignore/"
     // we return an empty js module (used by node esm)
@@ -132,9 +132,9 @@ export const jsenvPluginUrlResolution = ({
           content: "export default {}",
           contentType: "text/javascript",
           type: "js_module",
-        }
+        };
       }
-      return null
+      return null;
     },
-  }
-}
+  };
+};

package/src/plugins/url_resolution/node_esm_resolver.js

@@ -7,47 +7,47 @@
  *   it should likely be an other plugin happening after the others
  */
 
-import { readFileSync } from "node:fs"
-import { bufferToEtag } from "@jsenv/filesystem"
+import { readFileSync } from "node:fs";
+import { bufferToEtag } from "@jsenv/filesystem";
 import {
   applyNodeEsmResolution,
   readCustomConditionsFromProcessArgs,
   defaultLookupPackageScope,
   defaultReadPackageJson,
-} from "@jsenv/node-esm-resolution"
+} from "@jsenv/node-esm-resolution";
 
 export const createNodeEsmResolver = ({
   runtimeCompat,
   packageConditions,
   preservesSymlink,
 }) => {
-  const nodeRuntimeEnabled = Object.keys(runtimeCompat).includes("node")
+  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) => {
     if (reference.type === "package_json") {
-      return reference.specifier
+      return reference.specifier;
     }
-    const parentUrl = reference.baseUrl || reference.parentUrl
+    const parentUrl = reference.baseUrl || reference.parentUrl;
     if (!parentUrl.startsWith("file:")) {
-      return new URL(reference.specifier, parentUrl).href
+      return new URL(reference.specifier, parentUrl).href;
     }
     const { url, type, packageDirectoryUrl } = applyNodeEsmResolution({
       conditions: packageConditions,
       parentUrl,
       specifier: reference.specifier,
       preservesSymlink,
-    })
+    });
     if (context.dev) {
       const dependsOnPackageJson =
         type !== "relative_specifier" &&
         type !== "absolute_specifier" &&
-        type !== "node_builtin_specifier"
+        type !== "node_builtin_specifier";
       if (dependsOnPackageJson) {
         // this reference depends on package.json and node_modules
         // to be resolved. Each file using this specifier
@@ -59,7 +59,7 @@ export const createNodeEsmResolver = ({
           field: type.startsWith("field:")
             ? `#${type.slice("field:".length)}`
             : "",
-        })
+        });
       }
     }
     if (context.dev) {
@@ -67,13 +67,13 @@ export const createNodeEsmResolver = ({
       // 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)
+        const packageDirectoryUrl = defaultLookupPackageScope(url);
         if (
           packageDirectoryUrl &&
           packageDirectoryUrl !== context.rootDirectoryUrl
         ) {
           const packageVersion =
-            defaultReadPackageJson(packageDirectoryUrl).version
+            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({
@@ -82,15 +82,15 @@ export const createNodeEsmResolver = ({
               packageJsonUrl: `${packageDirectoryUrl}package.json`,
               field: "version",
               hasVersioningEffect: true,
-            })
+            });
           }
-          reference.version = packageVersion
+          reference.version = packageVersion;
         }
       }
     }
-    return url
-  }
-}
+    return url;
+  };
+};
 
 const addRelationshipWithPackageJson = ({
   context,
@@ -100,9 +100,9 @@ const addRelationshipWithPackageJson = ({
 }) => {
   const referenceFound = context.referenceUtils.find(
     (ref) => ref.type === "package_json" && ref.subtype === field,
-  )
+  );
   if (referenceFound) {
-    return
+    return;
   }
   const [, packageJsonUrlInfo] = context.referenceUtils.inject({
     type: "package_json",
@@ -110,12 +110,12 @@ const addRelationshipWithPackageJson = ({
     specifier: packageJsonUrl,
     isImplicit: true,
     hasVersioningEffect,
-  })
+  });
   if (packageJsonUrlInfo.type === undefined) {
-    const packageJsonContentAsBuffer = readFileSync(new URL(packageJsonUrl))
-    packageJsonUrlInfo.type = "json"
-    packageJsonUrlInfo.content = String(packageJsonContentAsBuffer)
+    const packageJsonContentAsBuffer = readFileSync(new URL(packageJsonUrl));
+    packageJsonUrlInfo.type = "json";
+    packageJsonUrlInfo.content = String(packageJsonContentAsBuffer);
     packageJsonUrlInfo.originalContentEtag = packageJsonUrlInfo.contentEtag =
-      bufferToEtag(packageJsonContentAsBuffer)
+      bufferToEtag(packageJsonContentAsBuffer);
   }
-}
+};

package/src/plugins/url_version/jsenv_plugin_url_version.js

@@ -9,25 +9,25 @@ 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 version = reference.searchParams.get("v")
+      const version = reference.searchParams.get("v");
       if (version) {
-        const urlObject = new URL(reference.url)
-        urlObject.searchParams.delete("v")
-        reference.version = version
-        return urlObject.href
+        const urlObject = new URL(reference.url);
+        urlObject.searchParams.delete("v");
+        reference.version = version;
+        return urlObject.href;
       }
-      return null
+      return null;
     },
     transformUrlSearchParams: (reference) => {
       if (!reference.version) {
-        return null
+        return null;
       }
       if (reference.searchParams.has("v")) {
-        return null
+        return null;
       }
       return {
         v: reference.version,
-      }
+      };
     },
-  }
-}
+  };
+};