@jsenv/core 35.0.5 → 36.0.1

package/src/plugins/reference_analysis/jsenv_plugin_reference_analysis.js

@@ -0,0 +1,120 @@
+import { URL_META } from "@jsenv/url-meta";
+
+import { jsenvPluginReferenceExpectedTypes } from "./jsenv_plugin_reference_expected_types.js";
+import { jsenvPluginDirectoryReferenceAnalysis } from "./directory/jsenv_plugin_directory_reference_analysis.js";
+import { jsenvPluginDataUrlsAnalysis } from "./data_urls/jsenv_plugin_data_urls_analysis.js";
+import { jsenvPluginHtmlReferenceAnalysis } from "./html/jsenv_plugin_html_reference_analysis.js";
+import { jsenvPluginWebmanifestReferenceAnalysis } from "./webmanifest/jsenv_plugin_webmanifest_reference_analysis.js";
+import { jsenvPluginCssReferenceAnalysis } from "./css/jsenv_plugin_css_reference_analysis.js";
+import { jsenvPluginJsReferenceAnalysis } from "./js/jsenv_plugin_js_reference_analysis.js";
+
+export const jsenvPluginReferenceAnalysis = ({
+  include,
+  supportedProtocols = ["file:", "data:", "virtual:", "http:", "https:"],
+
+  inlineContent = true,
+  inlineConvertedScript = false,
+  fetchInlineUrls = true,
+  allowEscapeForVersioning = false,
+}) => {
+  return [
+    jsenvPluginReferenceAnalysisInclude({
+      include,
+      supportedProtocols,
+    }),
+    jsenvPluginDirectoryReferenceAnalysis(),
+    jsenvPluginHtmlReferenceAnalysis({
+      inlineContent,
+      inlineConvertedScript,
+    }),
+    jsenvPluginWebmanifestReferenceAnalysis(),
+    jsenvPluginCssReferenceAnalysis(),
+    jsenvPluginJsReferenceAnalysis({
+      inlineContent,
+      allowEscapeForVersioning,
+    }),
+    ...(inlineContent ? [jsenvPluginDataUrlsAnalysis()] : []),
+    ...(inlineContent && fetchInlineUrls
+      ? [jsenvPluginInlineContentFetcher()]
+      : []),
+    jsenvPluginReferenceExpectedTypes(),
+  ];
+};
+
+const jsenvPluginReferenceAnalysisInclude = ({
+  include,
+  supportedProtocols,
+}) => {
+  // eslint-disable-next-line no-unused-vars
+  let getIncludeInfo = (url) => undefined;
+
+  return {
+    name: "jsenv:reference_analysis_include",
+    appliesDuring: "*",
+    init: ({ rootDirectoryUrl }) => {
+      if (include) {
+        const associations = URL_META.resolveAssociations(
+          { include },
+          rootDirectoryUrl,
+        );
+        getIncludeInfo = (url) => {
+          const { include } = URL_META.applyAssociations({
+            url,
+            associations,
+          });
+          return include;
+        };
+      }
+    },
+    redirectReference: (reference) => {
+      if (reference.shouldHandle !== undefined) {
+        return;
+      }
+      if (
+        reference.specifier[0] === "#" &&
+        // For Html, css and in general "#" refer to a resource in the page
+        // so that urls must be kept intact
+        // However for js import specifiers they have a different meaning and we want
+        // to resolve them (https://nodejs.org/api/packages.html#imports for instance)
+        reference.type !== "js_import"
+      ) {
+        reference.shouldHandle = false;
+        return;
+      }
+      const includeInfo = getIncludeInfo(reference.url);
+      if (includeInfo === true) {
+        reference.shouldHandle = true;
+        return;
+      }
+      if (includeInfo === false) {
+        reference.shouldHandle = false;
+        return;
+      }
+      const { protocol } = new URL(reference.url);
+      const protocolIsSupported = supportedProtocols.some(
+        (supportedProtocol) => protocol === supportedProtocol,
+      );
+      if (protocolIsSupported) {
+        reference.shouldHandle = true;
+      }
+    },
+  };
+};
+
+const jsenvPluginInlineContentFetcher = () => {
+  return {
+    name: "jsenv:inline_content_fetcher",
+    appliesDuring: "*",
+    fetchUrlContent: (urlInfo) => {
+      if (!urlInfo.isInline) {
+        return null;
+      }
+      return {
+        // we want to fetch the original content otherwise we might re-cook
+        // content already cooked
+        content: urlInfo.originalContent,
+        contentType: urlInfo.contentType,
+      };
+    },
+  };
+};

package/src/plugins/{url_analysis → reference_analysis}/jsenv_plugin_reference_expected_types.js

@@ -1,7 +1,7 @@
 import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
 
 export const jsenvPluginReferenceExpectedTypes = () => {
-  const redirectJsUrls = (reference) => {
+  const redirectJsReference = (reference) => {
     const urlObject = new URL(reference.url);
     const { searchParams } = urlObject;
 
@@ -10,23 +10,30 @@ export const jsenvPluginReferenceExpectedTypes = () => {
     }
     if (searchParams.has("js_classic")) {
       reference.expectedType = "js_classic";
-    } else if (
+    } else if (searchParams.has("js_module")) {
+      reference.expectedType = "js_module";
+    }
+    // we need to keep these checks here because during versioning:
+    // - only reference anlysis plugin is executed
+    //   -> plugin about js transpilation don't apply and can't set expectedType: 'js_classic'
+    // - query params like ?js_module_fallback are still there
+    // - without this check build would throw as reference could expect js module and find js classic
+    else if (
       searchParams.has("js_module_fallback") ||
       searchParams.has("as_js_classic")
     ) {
       reference.expectedType = "js_classic";
     } else if (searchParams.has("as_js_module")) {
       reference.expectedType = "js_module";
-    } else if (searchParams.has("js_module")) {
-      reference.expectedType = "js_module";
-    } else if (
+    }
+    // by default, js referenced by new URL is considered as "js_module"
+    // in case this is not desired code must use "?js_classic" like
+    // new URL('./file.js?js_classic', import.meta.url)
+    else if (
       reference.type === "js_url" &&
       reference.expectedType === undefined &&
       CONTENT_TYPE.fromUrlExtension(reference.url) === "text/javascript"
     ) {
-      // by default, js referenced by new URL is considered as "js_module"
-      // in case this is not desired code must use "?js_classic" like
-      // new URL('./file.js?js_classic', import.meta.url)
       reference.expectedType = "js_module";
     }
 
@@ -43,10 +50,10 @@ export const jsenvPluginReferenceExpectedTypes = () => {
   return {
     name: "jsenv:reference_expected_types",
     appliesDuring: "*",
-    redirectUrl: {
-      script: redirectJsUrls,
-      js_url: redirectJsUrls,
-      js_import: redirectJsUrls,
+    redirectReference: {
+      script: redirectJsReference,
+      js_url: redirectJsReference,
+      js_import: redirectJsReference,
     },
   };
 };

package/src/plugins/{url_analysis/webmanifest/webmanifest_urls.js → reference_analysis/webmanifest/jsenv_plugin_webmanifest_reference_analysis.js}

@@ -1,4 +1,16 @@
-export const parseAndTransformWebmanifestUrls = async (urlInfo, context) => {
+// css: parseAndTransformCssUrls,
+
+export const jsenvPluginWebmanifestReferenceAnalysis = () => {
+  return {
+    name: "jsenv:webmanifest_reference_analysis",
+    appliesDuring: "*",
+    transformUrlContent: {
+      webmanifest: parseAndTransformWebmanifestUrls,
+    },
+  };
+};
+
+const parseAndTransformWebmanifestUrls = async (urlInfo, context) => {
   const content = urlInfo.content;
   const manifest = JSON.parse(content);
   const actions = [];

package/src/plugins/resolution_node_esm/jsenv_plugin_node_esm_resolution.js

@@ -0,0 +1,74 @@
+import { urlTypeFromReference } from "../url_type_from_reference.js";
+import { createNodeEsmResolver } from "./node_esm_resolver.js";
+
+export const jsenvPluginNodeEsmResolution = (resolutionConfig = {}) => {
+  let nodeEsmResolverDefault;
+  const resolvers = {};
+  Object.keys(resolutionConfig).forEach((urlType) => {
+    const config = resolutionConfig[urlType];
+    if (config === true) {
+      resolvers[urlType] = (...args) => nodeEsmResolverDefault(...args);
+    } else if (config === false) {
+      resolvers[urlType] = () => null;
+    } else if (typeof config === "object") {
+      const { runtimeCompat, packageConditions, preservesSymlink, ...rest } =
+        config;
+      const unexpectedKeys = Object.keys(rest);
+      if (unexpectedKeys.length) {
+        throw new TypeError(
+          `${unexpectedKeys.join(
+            ",",
+          )}: there is no such configuration on "${urlType}"`,
+        );
+      }
+      resolvers[urlType] = createNodeEsmResolver({
+        runtimeCompat,
+        packageConditions,
+        preservesSymlink,
+      });
+    } else {
+      throw new TypeError(
+        `config must be true, false or an object, got ${config} on "${urlType}"`,
+      );
+    }
+  });
+
+  return {
+    name: "jsenv:node_esm_resolution",
+    appliesDuring: "*",
+    init: ({ runtimeCompat }) => {
+      nodeEsmResolverDefault = createNodeEsmResolver({
+        runtimeCompat,
+        preservesSymlink: true,
+      });
+      if (!resolvers.js_module) {
+        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 null;
+        };
+      }
+    },
+    resolveReference: (reference, context) => {
+      const urlType = urlTypeFromReference(reference, context);
+      const resolver = resolvers[urlType];
+      return resolver ? resolver(reference, context) : null;
+    },
+    // when specifier is prefixed by "file:///@ignore/"
+    // we return an empty js module
+    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 → resolution_node_esm}/node_esm_resolver.js

@@ -33,6 +33,14 @@ export const createNodeEsmResolver = ({
     if (reference.type === "package_json") {
       return reference.specifier;
     }
+    if (reference.specifier === "/") {
+      const { mainFilePath, rootDirectoryUrl } = context;
+      return String(new URL(mainFilePath, rootDirectoryUrl));
+    }
+    if (reference.specifier[0] === "/") {
+      return new URL(reference.specifier.slice(1), context.rootDirectoryUrl)
+        .href;
+    }
     const parentUrl = reference.baseUrl || reference.parentUrl;
     if (!parentUrl.startsWith("file:")) {
       return new URL(reference.specifier, parentUrl).href;

package/src/plugins/resolution_web/jsenv_plugin_web_resolution.js

@@ -0,0 +1,45 @@
+import { urlTypeFromReference } from "../url_type_from_reference.js";
+
+export const jsenvPluginWebResolution = (resolutionConfig = {}) => {
+  const resolvers = {};
+  const resolveUsingWebResolution = (reference, context) => {
+    if (reference.specifier === "/") {
+      const { mainFilePath, rootDirectoryUrl } = context;
+      return String(new URL(mainFilePath, rootDirectoryUrl));
+    }
+    if (reference.specifier[0] === "/") {
+      return new URL(reference.specifier.slice(1), context.rootDirectoryUrl)
+        .href;
+    }
+    return new URL(
+      reference.specifier,
+      // baseUrl happens second argument to new URL() is different from
+      // import.meta.url or document.currentScript.src
+      reference.baseUrl || reference.parentUrl,
+    ).href;
+  };
+  Object.keys(resolutionConfig).forEach((urlType) => {
+    const config = resolutionConfig[urlType];
+    if (config === true) {
+      resolvers[urlType] = resolveUsingWebResolution;
+    } else if (config === false) {
+      resolvers[urlType] = () => null;
+    } else {
+      throw new TypeError(
+        `config must be true or false, got ${config} on "${urlType}"`,
+      );
+    }
+  });
+
+  return {
+    name: "jsenv:web_resolution",
+    appliesDuring: "*",
+    resolveReference: (reference, context) => {
+      const urlType = urlTypeFromReference(reference, context);
+      const resolver = resolvers[urlType];
+      return resolver
+        ? resolver(reference, context)
+        : resolveUsingWebResolution(reference, context);
+    },
+  };
+};

package/src/plugins/transpilation/as_js_module/jsenv_plugin_as_js_module.js

@@ -17,7 +17,7 @@ export const jsenvPluginAsJsModule = () => {
   return {
     name: "jsenv:as_js_module",
     appliesDuring: "*",
-    redirectUrl: (reference) => {
+    redirectReference: (reference) => {
       if (reference.searchParams.has("as_js_module")) {
         reference.expectedType = "js_module";
         const filename = urlToFilename(reference.url);

package/src/plugins/transpilation/babel/jsenv_plugin_babel.js

@@ -92,7 +92,7 @@ export const jsenvPluginBabel = ({
   return {
     name: "jsenv:babel",
     appliesDuring: "*",
-    finalizeUrlContent: {
+    transformUrlContent: {
       js_classic: transformWithBabel,
       js_module: transformWithBabel,
     },

package/src/plugins/transpilation/import_assertions/jsenv_plugin_import_assertions.js

@@ -78,7 +78,7 @@ export const jsenvPluginImportAssertions = ({
         transpilations.text = true;
       }
     },
-    redirectUrl: (reference, context) => {
+    redirectReference: (reference, context) => {
       if (!reference.assert) {
         return null;
       }
@@ -103,7 +103,7 @@ export const jsenvPluginImportAssertions = ({
 
 const jsenvPluginAsModules = () => {
   const inlineContentClientFileUrl = new URL(
-    "../../inline_content_analysis/client/inline_content.js",
+    "../../reference_analysis/inline_content.js",
     import.meta.url,
   ).href;
 
@@ -181,11 +181,9 @@ const jsenvPluginAsModules = () => {
         canUseTemplateString: true,
       });
       return {
-        content: `import { InlineContent } from ${JSON.stringify(
-          inlineContentClientFileUrl,
-        )}
+        content: `import ${JSON.stringify(inlineContentClientFileUrl)}
   
-  const inlineContent = new InlineContent(${cssText}, { type: "text/css" })
+  const inlineContent = new __InlineContent__(${cssText}, { type: "text/css" })
   const stylesheet = new CSSStyleSheet()
   stylesheet.replaceSync(inlineContent.text)
   export default stylesheet`,

package/src/plugins/transpilation/js_module_fallback/jsenv_plugin_js_module_conversion.js

@@ -55,7 +55,7 @@ export const jsenvPluginJsModuleConversion = ({
   return {
     name: "jsenv:js_module_conversion",
     appliesDuring: "*",
-    redirectUrl: (reference, context) => {
+    redirectReference: (reference, context) => {
       if (reference.searchParams.has("js_module_fallback")) {
         markAsJsClassicProxy(reference);
         return null;

package/src/plugins/transpilation/js_module_fallback/jsenv_plugin_js_module_fallback_inside_html.js

@@ -30,7 +30,7 @@ export const jsenvPluginJsModuleFallbackInsideHtml = ({
   return {
     name: "jsenv:js_module_fallback_inside_html",
     appliesDuring: "*",
-    redirectUrl: {
+    redirectReference: {
       link_href: (reference, context) => {
         if (
           context.systemJsTranspilation &&
@@ -135,7 +135,6 @@ export const jsenvPluginJsModuleFallbackInsideHtml = ({
             }
           },
         });
-
         if (systemJsInjection) {
           let needsSystemJs = false;
           for (const reference of urlInfo.references) {
@@ -213,11 +212,10 @@ export const jsenvPluginJsModuleFallbackInsideHtml = ({
             });
           }
         }
-        if (mutations.length === 0) {
-          return null;
-        }
         await Promise.all(mutations.map((mutation) => mutation()));
-        return stringifyHtmlAst(htmlAst);
+        return stringifyHtmlAst(htmlAst, {
+          cleanupPositionAttributes: context.dev,
+        });
       },
     },
   };

package/src/plugins/transpilation/js_module_fallback/jsenv_plugin_js_module_fallback_on_workers.js

@@ -28,7 +28,7 @@ export const jsenvPluginJsModuleFallbackOnWorkers = () => {
   return {
     name: "jsenv:js_module_fallback_on_workers",
     appliesDuring: "*",
-    redirectUrl: {
+    redirectReference: {
       js_url: (reference, context) => {
         if (reference.expectedType !== "js_module") {
           return null;

package/src/plugins/url_type_from_reference.js

@@ -0,0 +1,13 @@
+export const urlTypeFromReference = (reference, context) => {
+  if (reference.type === "sourcemap_comment") {
+    return "sourcemap";
+  }
+  if (reference.injected) {
+    return reference.expectedType;
+  }
+  const parentUrlInfo = context.urlGraph.getUrlInfo(reference.parentUrl);
+  if (parentUrlInfo) {
+    return parentUrlInfo.type;
+  }
+  return "entry_point";
+};

package/src/plugins/{url_version/jsenv_plugin_url_version.js → version_search_param/jsenv_plugin_version_search_param.js}

@@ -1,8 +1,8 @@
-export const jsenvPluginUrlVersion = () => {
+export const jsenvPluginVersionSearchParam = () => {
   return {
-    name: "jsenv:url_version",
+    name: "jsenv:version_search_param",
     appliesDuring: "dev",
-    redirectUrl: (reference) => {
+    redirectReference: (reference) => {
       // "v" search param goal is to enable long-term cache
       // for server response headers
       // it is also used by hmr to bypass browser cache
@@ -18,7 +18,7 @@ export const jsenvPluginUrlVersion = () => {
       }
       return null;
     },
-    transformUrlSearchParams: (reference) => {
+    transformReferenceSearchParams: (reference) => {
       if (!reference.version) {
         return null;
       }