@jsenv/core 35.0.2 → 35.0.4

package/src/plugins/url_analysis/html/html_urls.js

@@ -8,20 +8,20 @@ import {
   analyzeScriptNode,
   parseSrcSet,
   stringifyHtmlAst,
-} from "@jsenv/ast"
+} from "@jsenv/ast";
 
 export const parseAndTransformHtmlUrls = async (urlInfo, context) => {
-  const url = urlInfo.originalUrl
-  const content = urlInfo.content
+  const url = urlInfo.originalUrl;
+  const content = urlInfo.content;
   const htmlAst = parseHtmlString(content, {
     storeOriginalPositions: context.dev,
-  })
+  });
   const mentions = visitHtmlUrls({
     url,
     htmlAst,
-  })
-  const mutations = []
-  const actions = []
+  });
+  const mutations = [];
+  const actions = [];
   for (const mention of mentions) {
     const {
       type,
@@ -35,15 +35,15 @@ export const parseAndTransformHtmlUrls = async (urlInfo, context) => {
       attributeName,
       debug,
       specifier,
-    } = mention
-    const { crossorigin, integrity } = readFetchMetas(node)
+    } = mention;
+    const { crossorigin, integrity } = readFetchMetas(node);
     const isResourceHint = [
       "preconnect",
       "dns-prefetch",
       "prefetch",
       "preload",
       "modulepreload",
-    ].includes(subtype)
+    ].includes(subtype);
     const [reference] = context.referenceUtils.found({
       type,
       subtype,
@@ -57,44 +57,44 @@ export const parseAndTransformHtmlUrls = async (urlInfo, context) => {
       crossorigin,
       integrity,
       debug,
-    })
+    });
     actions.push(async () => {
-      await context.referenceUtils.readGeneratedSpecifier(reference)
+      await context.referenceUtils.readGeneratedSpecifier(reference);
       mutations.push(() => {
         setHtmlNodeAttributes(node, {
           [attributeName]: reference.generatedSpecifier,
-        })
-      })
-    })
+        });
+      });
+    });
   }
   if (actions.length > 0) {
-    await Promise.all(actions.map((action) => action()))
+    await Promise.all(actions.map((action) => action()));
   }
   if (mutations.length === 0) {
-    return null
+    return null;
   }
-  mutations.forEach((mutation) => mutation())
-  return stringifyHtmlAst(htmlAst)
-}
+  mutations.forEach((mutation) => mutation());
+  return stringifyHtmlAst(htmlAst);
+};
 
-const crossOriginCompatibleTagNames = ["script", "link", "img", "source"]
-const integrityCompatibleTagNames = ["script", "link", "img", "source"]
+const crossOriginCompatibleTagNames = ["script", "link", "img", "source"];
+const integrityCompatibleTagNames = ["script", "link", "img", "source"];
 const readFetchMetas = (node) => {
-  const meta = {}
+  const meta = {};
   if (crossOriginCompatibleTagNames.includes(node.nodeName)) {
-    const crossorigin = getHtmlNodeAttribute(node, "crossorigin") !== undefined
-    meta.crossorigin = crossorigin
+    const crossorigin = getHtmlNodeAttribute(node, "crossorigin") !== undefined;
+    meta.crossorigin = crossorigin;
   }
   if (integrityCompatibleTagNames.includes(node.nodeName)) {
-    const integrity = getHtmlNodeAttribute(node, "integrity")
-    meta.integrity = integrity
+    const integrity = getHtmlNodeAttribute(node, "integrity");
+    meta.integrity = integrity;
   }
-  return meta
-}
+  return meta;
+};
 
 const visitHtmlUrls = ({ url, htmlAst }) => {
-  const mentions = []
-  const finalizeCallbacks = []
+  const mentions = [];
+  const finalizeCallbacks = [];
   const addMention = ({
     type,
     subtype,
@@ -103,20 +103,20 @@ const visitHtmlUrls = ({ url, htmlAst }) => {
     attributeName,
     specifier,
   }) => {
-    let position
+    let position;
     if (getHtmlNodeAttribute(node, "jsenv-cooked-by")) {
       // when generated from inline content,
       // line, column is not "src" nor "inlined-from-src" but "original-position"
-      position = getHtmlNodePosition(node)
+      position = getHtmlNodePosition(node);
     } else {
-      position = getHtmlNodeAttributePosition(node, attributeName)
+      position = getHtmlNodeAttributePosition(node, attributeName);
     }
     const {
       line,
       column,
       // originalLine, originalColumn
-    } = position
-    const debug = getHtmlNodeAttribute(node, "jsenv-debug") !== undefined
+    } = position;
+    const debug = getHtmlNodeAttribute(node, "jsenv-debug") !== undefined;
     const mention = {
       type,
       subtype,
@@ -128,19 +128,19 @@ const visitHtmlUrls = ({ url, htmlAst }) => {
       node,
       attributeName,
       debug,
-    }
-    mentions.push(mention)
-    return mention
-  }
+    };
+    mentions.push(mention);
+    return mention;
+  };
   const visitAttributeAsUrlSpecifier = ({ node, attributeName, ...rest }) => {
-    const value = getHtmlNodeAttribute(node, attributeName)
+    const value = getHtmlNodeAttribute(node, attributeName);
     if (value) {
       if (
         getHtmlNodeAttribute(node, "jsenv-inlined-by") === "jsenv:importmap"
       ) {
         // during build the importmap is inlined
         // and shoud not be considered as a dependency anymore
-        return null
+        return null;
       }
       return addMention({
         ...rest,
@@ -151,42 +151,42 @@ const visitHtmlUrls = ({ url, htmlAst }) => {
           attributeName === "inlined-from-href"
             ? new URL(value, url).href
             : value,
-      })
+      });
     }
     if (attributeName === "src") {
       return visitAttributeAsUrlSpecifier({
         ...rest,
         node,
         attributeName: "inlined-from-src",
-      })
+      });
     }
     if (attributeName === "href") {
       return visitAttributeAsUrlSpecifier({
         ...rest,
         node,
         attributeName: "inlined-from-href",
-      })
+      });
     }
-    return null
-  }
+    return null;
+  };
   const visitSrcset = ({ type, node }) => {
-    const srcset = getHtmlNodeAttribute(node, "srcset")
+    const srcset = getHtmlNodeAttribute(node, "srcset");
     if (srcset) {
-      const srcCandidates = parseSrcSet(srcset)
+      const srcCandidates = parseSrcSet(srcset);
       srcCandidates.forEach((srcCandidate) => {
         addMention({
           type,
           node,
           attributeName: "srcset",
           specifier: srcCandidate.specifier,
-        })
-      })
+        });
+      });
     }
-  }
+  };
   visitHtmlNodes(htmlAst, {
     link: (node) => {
-      const rel = getHtmlNodeAttribute(node, "rel")
-      const type = getHtmlNodeAttribute(node, "type")
+      const rel = getHtmlNodeAttribute(node, "rel");
+      const type = getHtmlNodeAttribute(node, "type");
       const mention = visitAttributeAsUrlSpecifier({
         type: "link_href",
         subtype: rel,
@@ -194,22 +194,22 @@ const visitHtmlUrls = ({ url, htmlAst }) => {
         attributeName: "href",
         // https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/preload#including_a_mime_type
         expectedContentType: type,
-      })
+      });
 
       if (mention) {
         finalizeCallbacks.push(() => {
-          mention.expectedType = decideLinkExpectedType(mention, mentions)
-        })
+          mention.expectedType = decideLinkExpectedType(mention, mentions);
+        });
       }
     },
     // style: () => {},
     script: (node) => {
-      const { type } = analyzeScriptNode(node)
+      const { type } = analyzeScriptNode(node);
       if (type === "text") {
         // ignore <script type="whatever" src="./file.js">
         // per HTML spec https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-type
         // this will be handled by jsenv_plugin_html_inline_content_analysis
-        return
+        return;
       }
       visitAttributeAsUrlSpecifier({
         type: "script",
@@ -217,43 +217,43 @@ const visitHtmlUrls = ({ url, htmlAst }) => {
         expectedType: type,
         node,
         attributeName: "src",
-      })
+      });
     },
     a: (node) => {
       visitAttributeAsUrlSpecifier({
         type: "a_href",
         node,
         attributeName: "href",
-      })
+      });
     },
     iframe: (node) => {
       visitAttributeAsUrlSpecifier({
         type: "iframe_src",
         node,
         attributeName: "src",
-      })
+      });
     },
     img: (node) => {
       visitAttributeAsUrlSpecifier({
         type: "img_src",
         node,
         attributeName: "src",
-      })
+      });
       visitSrcset({
         type: "img_srcset",
         node,
-      })
+      });
     },
     source: (node) => {
       visitAttributeAsUrlSpecifier({
         type: "source_src",
         node,
         attributeName: "src",
-      })
+      });
       visitSrcset({
         type: "source_srcset",
         node,
-      })
+      });
     },
     // svg <image> tag
     image: (node) => {
@@ -261,53 +261,53 @@ const visitHtmlUrls = ({ url, htmlAst }) => {
         type: "image_href",
         node,
         attributeName: "href",
-      })
+      });
     },
     use: (node) => {
       visitAttributeAsUrlSpecifier({
         type: "use_href",
         node,
         attributeName: "href",
-      })
+      });
     },
-  })
+  });
   finalizeCallbacks.forEach((finalizeCallback) => {
-    finalizeCallback()
-  })
-  return mentions
-}
+    finalizeCallback();
+  });
+  return mentions;
+};
 
 const decideLinkExpectedType = (linkMention, mentions) => {
-  const rel = getHtmlNodeAttribute(linkMention.node, "rel")
+  const rel = getHtmlNodeAttribute(linkMention.node, "rel");
   if (rel === "webmanifest") {
-    return "webmanifest"
+    return "webmanifest";
   }
   if (rel === "modulepreload") {
-    return "js_module"
+    return "js_module";
   }
   if (rel === "stylesheet") {
-    return "css"
+    return "css";
   }
   if (rel === "preload") {
     // https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/preload#what_types_of_content_can_be_preloaded
-    const as = getHtmlNodeAttribute(linkMention.node, "as")
+    const as = getHtmlNodeAttribute(linkMention.node, "as");
     if (as === "document") {
-      return "html"
+      return "html";
     }
     if (as === "style") {
-      return "css"
+      return "css";
     }
     if (as === "script") {
       const firstScriptOnThisUrl = mentions.find(
         (mentionCandidate) =>
           mentionCandidate.url === linkMention.url &&
           mentionCandidate.type === "script",
-      )
+      );
       if (firstScriptOnThisUrl) {
-        return firstScriptOnThisUrl.expectedType
+        return firstScriptOnThisUrl.expectedType;
       }
-      return undefined
+      return undefined;
     }
   }
-  return undefined
-}
+  return undefined;
+};

package/src/plugins/url_analysis/js/js_urls.js

@@ -1,7 +1,7 @@
-import { createMagicSource } from "@jsenv/sourcemap"
-import { parseJsUrls } from "@jsenv/ast"
+import { createMagicSource } from "@jsenv/sourcemap";
+import { parseJsUrls } from "@jsenv/ast";
 
-import { isWebWorkerUrlInfo } from "@jsenv/core/src/kitchen/web_workers.js"
+import { isWebWorkerUrlInfo } from "@jsenv/core/src/kitchen/web_workers.js";
 
 export const parseAndTransformJsUrls = async (urlInfo, context) => {
   const jsMentions = await parseJsUrls({
@@ -9,15 +9,15 @@ export const parseAndTransformJsUrls = async (urlInfo, context) => {
     url: urlInfo.originalUrl,
     isJsModule: urlInfo.type === "js_module",
     isWebWorker: isWebWorkerUrlInfo(urlInfo),
-  })
-  const actions = []
-  const magicSource = createMagicSource(urlInfo.content)
+  });
+  const actions = [];
+  const magicSource = createMagicSource(urlInfo.content);
   for (const jsMention of jsMentions) {
     if (
       jsMention.subtype === "import_static" ||
       jsMention.subtype === "import_dynamic"
     ) {
-      urlInfo.data.usesImport = true
+      urlInfo.data.usesImport = true;
     }
     const [reference] = context.referenceUtils.found({
       node: jsMention.node,
@@ -42,24 +42,24 @@ export const parseAndTransformJsUrls = async (urlInfo, context) => {
       assert: jsMention.assert,
       assertNode: jsMention.assertNode,
       typePropertyNode: jsMention.typePropertyNode,
-    })
+    });
     actions.push(async () => {
       const replacement = await context.referenceUtils.readGeneratedSpecifier(
         reference,
-      )
+      );
       magicSource.replace({
         start: jsMention.start,
         end: jsMention.end,
         replacement,
-      })
+      });
       if (reference.mutation) {
-        reference.mutation(magicSource)
+        reference.mutation(magicSource);
       }
-    })
+    });
   }
   if (actions.length > 0) {
-    await Promise.all(actions.map((action) => action()))
+    await Promise.all(actions.map((action) => action()));
   }
-  const { content, sourcemap } = magicSource.toContentAndSourcemap()
-  return { content, sourcemap }
-}
+  const { content, sourcemap } = magicSource.toContentAndSourcemap();
+  return { content, sourcemap };
+};

package/src/plugins/url_analysis/jsenv_plugin_reference_expected_types.js

@@ -1,24 +1,24 @@
-import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
 
 export const jsenvPluginReferenceExpectedTypes = () => {
   const redirectJsUrls = (reference) => {
-    const urlObject = new URL(reference.url)
-    const { searchParams } = urlObject
+    const urlObject = new URL(reference.url);
+    const { searchParams } = urlObject;
 
     if (searchParams.has("entry_point")) {
-      reference.isEntryPoint = true
+      reference.isEntryPoint = true;
     }
     if (searchParams.has("js_classic")) {
-      reference.expectedType = "js_classic"
+      reference.expectedType = "js_classic";
     } else if (
       searchParams.has("js_module_fallback") ||
       searchParams.has("as_js_classic")
     ) {
-      reference.expectedType = "js_classic"
+      reference.expectedType = "js_classic";
     } else if (searchParams.has("as_js_module")) {
-      reference.expectedType = "js_module"
+      reference.expectedType = "js_module";
     } else if (searchParams.has("js_module")) {
-      reference.expectedType = "js_module"
+      reference.expectedType = "js_module";
     } else if (
       reference.type === "js_url" &&
       reference.expectedType === undefined &&
@@ -27,18 +27,18 @@ export const jsenvPluginReferenceExpectedTypes = () => {
       // 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"
+      reference.expectedType = "js_module";
     }
 
     if (searchParams.has("worker")) {
-      reference.expectedSubtype = "worker"
+      reference.expectedSubtype = "worker";
     } else if (searchParams.has("service_worker")) {
-      reference.expectedSubtype = "service_worker"
+      reference.expectedSubtype = "service_worker";
     } else if (searchParams.has("shared_worker")) {
-      reference.expectedSubtype = "shared_worker"
+      reference.expectedSubtype = "shared_worker";
     }
-    return urlObject.href
-  }
+    return urlObject.href;
+  };
 
   return {
     name: "jsenv:reference_expected_types",
@@ -48,5 +48,5 @@ export const jsenvPluginReferenceExpectedTypes = () => {
       js_url: redirectJsUrls,
       js_import: redirectJsUrls,
     },
-  }
-}
+  };
+};

package/src/plugins/url_analysis/jsenv_plugin_url_analysis.js

@@ -1,11 +1,11 @@
-import { URL_META } from "@jsenv/url-meta"
-import { urlToRelativeUrl } from "@jsenv/urls"
+import { URL_META } from "@jsenv/url-meta";
+import { urlToRelativeUrl } from "@jsenv/urls";
 
-import { jsenvPluginReferenceExpectedTypes } from "./jsenv_plugin_reference_expected_types.js"
-import { parseAndTransformHtmlUrls } from "./html/html_urls.js"
-import { parseAndTransformCssUrls } from "./css/css_urls.js"
-import { parseAndTransformJsUrls } from "./js/js_urls.js"
-import { parseAndTransformWebmanifestUrls } from "./webmanifest/webmanifest_urls.js"
+import { jsenvPluginReferenceExpectedTypes } from "./jsenv_plugin_reference_expected_types.js";
+import { parseAndTransformHtmlUrls } from "./html/html_urls.js";
+import { parseAndTransformCssUrls } from "./css/css_urls.js";
+import { parseAndTransformJsUrls } from "./js/js_urls.js";
+import { parseAndTransformWebmanifestUrls } from "./webmanifest/webmanifest_urls.js";
 
 export const jsenvPluginUrlAnalysis = ({
   rootDirectoryUrl,
@@ -13,16 +13,16 @@ export const jsenvPluginUrlAnalysis = ({
   supportedProtocols = ["file:", "data:", "virtual:", "http:", "https:"],
 }) => {
   // eslint-disable-next-line no-unused-vars
-  let getIncludeInfo = (url) => undefined
+  let getIncludeInfo = (url) => undefined;
   if (include) {
     const associations = URL_META.resolveAssociations(
       { include },
       rootDirectoryUrl,
-    )
+    );
     getIncludeInfo = (url) => {
-      const { include } = URL_META.applyAssociations({ url, associations })
-      return include
-    }
+      const { include } = URL_META.applyAssociations({ url, associations });
+      return include;
+    };
   }
 
   return [
@@ -31,7 +31,7 @@ export const jsenvPluginUrlAnalysis = ({
       appliesDuring: "*",
       redirectUrl: (reference) => {
         if (reference.shouldHandle !== undefined) {
-          return
+          return;
         }
         if (
           reference.specifier[0] === "#" &&
@@ -41,24 +41,24 @@ export const jsenvPluginUrlAnalysis = ({
           // to resolve them (https://nodejs.org/api/packages.html#imports for instance)
           reference.type !== "js_import"
         ) {
-          reference.shouldHandle = false
-          return
+          reference.shouldHandle = false;
+          return;
         }
-        const includeInfo = getIncludeInfo(reference.url)
+        const includeInfo = getIncludeInfo(reference.url);
         if (includeInfo === true) {
-          reference.shouldHandle = true
-          return
+          reference.shouldHandle = true;
+          return;
         }
         if (includeInfo === false) {
-          reference.shouldHandle = false
-          return
+          reference.shouldHandle = false;
+          return;
         }
-        const { protocol } = new URL(reference.url)
+        const { protocol } = new URL(reference.url);
         const protocolIsSupported = supportedProtocols.some(
           (supportedProtocol) => protocol === supportedProtocol,
-        )
+        );
         if (protocolIsSupported) {
-          reference.shouldHandle = true
+          reference.shouldHandle = true;
         }
       },
       transformUrlContent: {
@@ -71,11 +71,11 @@ export const jsenvPluginUrlAnalysis = ({
           const originalDirectoryReference = findOriginalDirectoryReference(
             urlInfo,
             context,
-          )
+          );
           const directoryRelativeUrl = urlToRelativeUrl(
             urlInfo.url,
             context.rootDirectoryUrl,
-          )
+          );
           JSON.parse(urlInfo.content).forEach((directoryEntryName) => {
             context.referenceUtils.found({
               type: "filesystem",
@@ -84,33 +84,33 @@ export const jsenvPluginUrlAnalysis = ({
               trace: {
                 message: `"${directoryRelativeUrl}${directoryEntryName}" entry in directory referenced by ${originalDirectoryReference.trace.message}`,
               },
-            })
-          })
+            });
+          });
         },
       },
     },
     jsenvPluginReferenceExpectedTypes(),
-  ]
-}
+  ];
+};
 
 const findOriginalDirectoryReference = (urlInfo, context) => {
   const findNonFileSystemAncestor = (urlInfo) => {
     for (const dependentUrl of urlInfo.dependents) {
-      const dependentUrlInfo = context.urlGraph.getUrlInfo(dependentUrl)
+      const dependentUrlInfo = context.urlGraph.getUrlInfo(dependentUrl);
       if (dependentUrlInfo.type !== "directory") {
-        return [dependentUrlInfo, urlInfo]
+        return [dependentUrlInfo, urlInfo];
       }
-      const found = findNonFileSystemAncestor(dependentUrlInfo)
+      const found = findNonFileSystemAncestor(dependentUrlInfo);
       if (found) {
-        return found
+        return found;
       }
     }
-    return []
-  }
-  const [ancestor, child] = findNonFileSystemAncestor(urlInfo)
+    return [];
+  };
+  const [ancestor, child] = findNonFileSystemAncestor(urlInfo);
   if (!ancestor) {
-    return null
+    return null;
   }
-  const ref = ancestor.references.find((ref) => ref.url === child.url)
-  return ref
-}
+  const ref = ancestor.references.find((ref) => ref.url === child.url);
+  return ref;
+};

package/src/plugins/url_analysis/webmanifest/webmanifest_urls.js

@@ -1,21 +1,21 @@
 export const parseAndTransformWebmanifestUrls = async (urlInfo, context) => {
-  const content = urlInfo.content
-  const manifest = JSON.parse(content)
-  const actions = []
-  const { icons = [] } = manifest
+  const content = urlInfo.content;
+  const manifest = JSON.parse(content);
+  const actions = [];
+  const { icons = [] } = manifest;
   icons.forEach((icon) => {
     const [reference] = context.referenceUtils.found({
       type: "webmanifest_icon_src",
       specifier: icon.src,
-    })
+    });
     actions.push(async () => {
-      icon.src = await context.referenceUtils.readGeneratedSpecifier(reference)
-    })
-  })
+      icon.src = await context.referenceUtils.readGeneratedSpecifier(reference);
+    });
+  });
 
   if (actions.length === 0) {
-    return null
+    return null;
   }
-  await Promise.all(actions.map((action) => action()))
-  return JSON.stringify(manifest, null, "  ")
-}
+  await Promise.all(actions.map((action) => action()));
+  return JSON.stringify(manifest, null, "  ");
+};