@jsenv/core 35.0.2 → 35.0.4

package/src/plugins/inlining/jsenv_plugin_inlining.js

@@ -1,5 +1,5 @@
-import { jsenvPluginInliningAsDataUrl } from "./jsenv_plugin_inlining_as_data_url.js"
-import { jsenvPluginInliningIntoHtml } from "./jsenv_plugin_inlining_into_html.js"
+import { jsenvPluginInliningAsDataUrl } from "./jsenv_plugin_inlining_as_data_url.js";
+import { jsenvPluginInliningIntoHtml } from "./jsenv_plugin_inlining_into_html.js";
 
 export const jsenvPluginInlining = () => {
   return [
@@ -7,16 +7,16 @@ export const jsenvPluginInlining = () => {
       name: "jsenv:inlining",
       appliesDuring: "*",
       redirectUrl: (reference) => {
-        const { searchParams } = reference
+        const { searchParams } = reference;
         if (searchParams.has("inline")) {
-          const urlObject = new URL(reference.url)
-          urlObject.searchParams.delete("inline")
-          return urlObject.href
+          const urlObject = new URL(reference.url);
+          urlObject.searchParams.delete("inline");
+          return urlObject.href;
         }
-        return null
+        return null;
       },
     },
     jsenvPluginInliningAsDataUrl(),
     jsenvPluginInliningIntoHtml(),
-  ]
-}
+  ];
+};

package/src/plugins/inlining/jsenv_plugin_inlining_as_data_url.js

@@ -1,4 +1,4 @@
-import { DATA_URL } from "@jsenv/urls"
+import { DATA_URL } from "@jsenv/urls";
 
 export const jsenvPluginInliningAsDataUrl = () => {
   return {
@@ -19,29 +19,29 @@ export const jsenvPluginInliningAsDataUrl = () => {
           !reference.original ||
           !reference.original.searchParams.has("inline")
         ) {
-          return null
+          return null;
         }
         // <link rel="stylesheet"> and <script> can be inlined in the html
         if (
           reference.type === "link_href" &&
           reference.subtype === "stylesheet"
         ) {
-          return null
+          return null;
         }
         if (reference.type === "script") {
-          return null
+          return null;
         }
         return (async () => {
-          const urlInfo = context.urlGraph.getUrlInfo(reference.url)
-          await context.cook(urlInfo, { reference })
+          const urlInfo = context.urlGraph.getUrlInfo(reference.url);
+          await context.cook(urlInfo, { reference });
           const specifier = DATA_URL.stringify({
             mediaType: urlInfo.contentType,
             base64Flag: true,
             data: Buffer.from(urlInfo.content).toString("base64"),
-          })
-          return specifier
-        })()
+          });
+          return specifier;
+        })();
       },
     },
-  }
-}
+  };
+};

package/src/plugins/inlining/jsenv_plugin_inlining_into_html.js

@@ -8,7 +8,7 @@ import {
   setHtmlNodeAttributes,
   setHtmlNodeText,
   getHtmlNodePosition,
-} from "@jsenv/ast"
+} from "@jsenv/ast";
 
 export const jsenvPluginInliningIntoHtml = () => {
   return {
@@ -16,9 +16,9 @@ export const jsenvPluginInliningIntoHtml = () => {
     appliesDuring: "*",
     transformUrlContent: {
       html: async (urlInfo, context) => {
-        const htmlAst = parseHtmlString(urlInfo.content)
-        const mutations = []
-        const actions = []
+        const htmlAst = parseHtmlString(urlInfo.content);
+        const mutations = [];
+        const actions = [];
 
         const onStyleSheet = (linkNode, { href }) => {
           const linkReference = context.referenceUtils.find(
@@ -26,21 +26,21 @@ export const jsenvPluginInliningIntoHtml = () => {
               ref.generatedSpecifier === href &&
               ref.type === "link_href" &&
               ref.subtype === "stylesheet",
-          )
+          );
           if (
             !linkReference.original ||
             !linkReference.original.searchParams.has("inline")
           ) {
-            return
+            return;
           }
-          const linkUrlInfo = context.urlGraph.getUrlInfo(linkReference.url)
+          const linkUrlInfo = context.urlGraph.getUrlInfo(linkReference.url);
           actions.push(async () => {
             await context.cook(linkUrlInfo, {
               reference: linkReference,
-            })
+            });
             const { line, column, isOriginal } = getHtmlNodePosition(linkNode, {
               preferOriginal: true,
-            })
+            });
             context.referenceUtils.becomesInline(linkReference, {
               line: line - 1,
               column,
@@ -48,7 +48,7 @@ export const jsenvPluginInliningIntoHtml = () => {
               specifier: linkReference.generatedSpecifier,
               content: linkUrlInfo.content,
               contentType: linkUrlInfo.contentType,
-            })
+            });
             mutations.push(() => {
               setHtmlNodeAttributes(linkNode, {
                 "inlined-from-href": href,
@@ -59,36 +59,38 @@ export const jsenvPluginInliningIntoHtml = () => {
                 "crossorigin": undefined,
                 "integrity": undefined,
                 "jsenv-inlined-by": "jsenv:inlining_into_html",
-              })
-              linkNode.nodeName = "style"
-              linkNode.tagName = "style"
+              });
+              linkNode.nodeName = "style";
+              linkNode.tagName = "style";
               setHtmlNodeText(linkNode, linkUrlInfo.content, {
                 indentation: "auto",
-              })
-            })
-          })
-        }
+              });
+            });
+          });
+        };
         const onScriptWithSrc = (scriptNode, { src }) => {
           const scriptReference = context.referenceUtils.find(
             (ref) => ref.generatedSpecifier === src && ref.type === "script",
-          )
+          );
           if (
             !scriptReference.original ||
             !scriptReference.original.searchParams.has("inline")
           ) {
-            return
+            return;
           }
-          const scriptUrlInfo = context.urlGraph.getUrlInfo(scriptReference.url)
+          const scriptUrlInfo = context.urlGraph.getUrlInfo(
+            scriptReference.url,
+          );
           actions.push(async () => {
             await context.cook(scriptUrlInfo, {
               reference: scriptReference,
-            })
+            });
             const { line, column, isOriginal } = getHtmlNodePosition(
               scriptNode,
               {
                 preferOriginal: true,
               },
-            )
+            );
             context.referenceUtils.becomesInline(scriptReference, {
               line: line - 1,
               column,
@@ -96,7 +98,7 @@ export const jsenvPluginInliningIntoHtml = () => {
               specifier: scriptReference.generatedSpecifier,
               content: scriptUrlInfo.content,
               contentType: scriptUrlInfo.contentType,
-            })
+            });
             mutations.push(() => {
               setHtmlNodeAttributes(scriptNode, {
                 "inlined-from-src": src,
@@ -104,46 +106,46 @@ export const jsenvPluginInliningIntoHtml = () => {
                 "crossorigin": undefined,
                 "integrity": undefined,
                 "jsenv-inlined-by": "jsenv:inlining_into_html",
-              })
+              });
               setHtmlNodeText(scriptNode, scriptUrlInfo.content, {
                 indentation: "auto",
-              })
-            })
-          })
-        }
+              });
+            });
+          });
+        };
 
         visitHtmlNodes(htmlAst, {
           link: (linkNode) => {
-            const rel = getHtmlNodeAttribute(linkNode, "rel")
+            const rel = getHtmlNodeAttribute(linkNode, "rel");
             if (rel !== "stylesheet") {
-              return
+              return;
             }
-            const href = getHtmlNodeAttribute(linkNode, "href")
+            const href = getHtmlNodeAttribute(linkNode, "href");
             if (!href) {
-              return
+              return;
             }
-            onStyleSheet(linkNode, { href })
+            onStyleSheet(linkNode, { href });
           },
           script: (scriptNode) => {
-            const { type } = analyzeScriptNode(scriptNode)
-            const scriptNodeText = getHtmlNodeText(scriptNode)
+            const { type } = analyzeScriptNode(scriptNode);
+            const scriptNodeText = getHtmlNodeText(scriptNode);
             if (scriptNodeText) {
-              return
+              return;
             }
-            const src = getHtmlNodeAttribute(scriptNode, "src")
+            const src = getHtmlNodeAttribute(scriptNode, "src");
             if (!src) {
-              return
+              return;
             }
-            onScriptWithSrc(scriptNode, { type, src })
+            onScriptWithSrc(scriptNode, { type, src });
           },
-        })
+        });
         if (actions.length > 0) {
-          await Promise.all(actions.map((action) => action()))
+          await Promise.all(actions.map((action) => action()));
         }
-        mutations.forEach((mutation) => mutation())
-        const htmlModified = stringifyHtmlAst(htmlAst)
-        return htmlModified
+        mutations.forEach((mutation) => mutation());
+        const htmlModified = stringifyHtmlAst(htmlAst);
+        return htmlModified;
       },
     },
-  }
-}
+  };
+};

package/src/plugins/node_runtime/jsenv_plugin_node_runtime.js

@@ -1,12 +1,12 @@
 export const jsenvPluginNodeRuntime = ({ runtimeCompat }) => {
-  const nodeFound = Object.keys(runtimeCompat).includes("node")
+  const nodeFound = Object.keys(runtimeCompat).includes("node");
   if (!nodeFound) {
-    return []
+    return [];
   }
 
   // what do we need to do?
   return {
     name: "jsenv:node_runtime",
     appliesDuring: "*",
-  }
-}
+  };
+};