@jsenv/core 35.0.2 → 35.0.4

package/src/plugins/global_scenarios/jsenv_plugin_global_scenarios.js

@@ -5,15 +5,15 @@
  * A global will be injected with true/false when needed
  */
 
-import { replacePlaceholders } from "@jsenv/plugin-placeholders"
+import { replacePlaceholders } from "@jsenv/plugin-placeholders";
 
 export const jsenvPluginGlobalScenarios = () => {
   const transformIfNeeded = (urlInfo, context) => {
     return replacePlaceholders(urlInfo, {
       __DEV__: context.dev,
       __BUILD__: context.build,
-    })
-  }
+    });
+  };
 
   return {
     name: "jsenv:global_scenario",
@@ -23,5 +23,5 @@ export const jsenvPluginGlobalScenarios = () => {
       js_module: transformIfNeeded,
       html: transformIfNeeded,
     },
-  }
-}
+  };
+};

package/src/plugins/http_urls/jsenv_plugin_http_urls.js

@@ -7,10 +7,10 @@ export const jsenvPluginHttpUrls = () => {
         reference.url.startsWith("http:") ||
         reference.url.startsWith("https:")
       ) {
-        reference.shouldHandle = false
+        reference.shouldHandle = false;
       }
       // TODO: according to some pattern matching jsenv could be allowed
       // to fetch and transform http urls
     },
-  }
-}
+  };
+};

package/src/plugins/import_meta_hot/babel_plugin_metadata_import_meta_hot.js

@@ -10,82 +10,82 @@ export const babelPluginMetadataImportMetaHot = () => {
         Object.assign(
           state.file.metadata,
           collectImportMetaProperties(programPath),
-        )
+        );
       },
     },
-  }
-}
+  };
+};
 const collectImportMetaProperties = (programPath) => {
-  const importMetaHotPaths = []
-  let hotDecline = false
-  let hotAcceptSelf = false
-  let hotAcceptDependencies = []
+  const importMetaHotPaths = [];
+  let hotDecline = false;
+  let hotAcceptSelf = false;
+  let hotAcceptDependencies = [];
   programPath.traverse({
     MemberExpression(path) {
-      const { node } = path
-      const { object } = node
+      const { node } = path;
+      const { object } = node;
       if (object.type !== "MetaProperty") {
-        return
+        return;
       }
-      const { property: objectProperty } = object
+      const { property: objectProperty } = object;
       if (objectProperty.name !== "meta") {
-        return
+        return;
       }
-      const { property } = node
-      const { name } = property
+      const { property } = node;
+      const { name } = property;
       if (name === "hot") {
-        importMetaHotPaths.push(path)
+        importMetaHotPaths.push(path);
       }
     },
     CallExpression(path) {
       if (isImportMetaHotMethodCall(path, "accept")) {
-        const callNode = path.node
-        const args = callNode.arguments
+        const callNode = path.node;
+        const args = callNode.arguments;
         if (args.length === 0) {
-          hotAcceptSelf = true
-          return
+          hotAcceptSelf = true;
+          return;
         }
-        const firstArg = args[0]
+        const firstArg = args[0];
         if (firstArg.type === "StringLiteral") {
           hotAcceptDependencies = [
             {
               specifierPath: path.get("arguments")[0],
             },
-          ]
-          return
+          ];
+          return;
         }
         if (firstArg.type === "ArrayExpression") {
-          const firstArgPath = path.get("arguments")[0]
+          const firstArgPath = path.get("arguments")[0];
           hotAcceptDependencies = firstArg.elements.map((arrayNode, index) => {
             if (arrayNode.type !== "StringLiteral") {
               throw new Error(
                 `all array elements must be strings in "import.meta.hot.accept(array)"`,
-              )
+              );
             }
             return {
               specifierPath: firstArgPath.get(String(index)),
-            }
-          })
-          return
+            };
+          });
+          return;
         }
         // accept first arg can be "anything" such as
         // `const cb = () => {}; import.meta.accept(cb)`
-        hotAcceptSelf = true
+        hotAcceptSelf = true;
       }
       if (isImportMetaHotMethodCall(path, "decline")) {
-        hotDecline = true
+        hotDecline = true;
       }
     },
-  })
+  });
   return {
     importMetaHotPaths,
     hotDecline,
     hotAcceptSelf,
     hotAcceptDependencies,
-  }
-}
+  };
+};
 const isImportMetaHotMethodCall = (path, methodName) => {
-  const { property, object } = path.node.callee
+  const { property, object } = path.node.callee;
   return (
     property &&
     property.name === methodName &&
@@ -93,5 +93,5 @@ const isImportMetaHotMethodCall = (path, methodName) => {
     object.property &&
     object.property.name === "hot" &&
     object.object.type === "MetaProperty"
-  )
-}
+  );
+};

package/src/plugins/import_meta_hot/client/import_meta_hot.js

@@ -3,11 +3,11 @@
  * https://modern-web.dev/docs/dev-server/plugins/hmr/
  */
 
-export const urlHotMetas = {}
+export const urlHotMetas = {};
 
 export const createImportMetaHot = (importMetaUrl) => {
-  const data = {}
-  const url = asUrlWithoutHmrQuery(importMetaUrl)
+  const data = {};
+  const url = asUrlWithoutHmrQuery(importMetaUrl);
 
   return {
     data,
@@ -16,67 +16,67 @@ export const createImportMetaHot = (importMetaUrl) => {
         addUrlMeta(url, {
           dependencies: [url],
           acceptCallback: () => {},
-        })
-        return
+        });
+        return;
       }
       if (typeof firstArg === "function") {
         addUrlMeta(url, {
           dependencies: [url],
           acceptCallback: firstArg,
-        })
-        return
+        });
+        return;
       }
       if (typeof firstArg === "string") {
         addUrlMeta(url, {
           dependencies: [firstArg],
           acceptCallback: secondArg,
-        })
-        return
+        });
+        return;
       }
       if (Array.isArray(firstArg)) {
         addUrlMeta(url, {
           dependencies: firstArg,
           acceptCallback: secondArg,
-        })
-        return
+        });
+        return;
       }
       throw new Error(
         `invalid call to import.meta.hot.accept(), received ${firstArg}`,
-      )
+      );
     },
     dispose: (callback) => {
       addUrlMeta(url, {
         disposeCallback: () => {
-          return callback(data)
+          return callback(data);
         },
-      })
+      });
     },
     decline: () => {
       addUrlMeta(url, {
         declined: true,
-      })
+      });
     },
     invalidate: () => {
       addUrlMeta(url, {
         invalidated: true,
-      })
+      });
     },
-  }
-}
+  };
+};
 
 const addUrlMeta = (url, meta) => {
   urlHotMetas[url] = {
     ...urlHotMetas[url],
     ...meta,
-  }
-}
+  };
+};
 
 const asUrlWithoutHmrQuery = (url) => {
-  const urlObject = new URL(url)
+  const urlObject = new URL(url);
   if (urlObject.searchParams.has("hmr")) {
-    urlObject.searchParams.delete("hmr")
-    urlObject.searchParams.delete("v")
-    return urlObject.href
+    urlObject.searchParams.delete("hmr");
+    urlObject.searchParams.delete("v");
+    return urlObject.href;
   }
-  return url
-}
+  return url;
+};

package/src/plugins/import_meta_hot/html_hot_dependencies.js

@@ -1,4 +1,4 @@
-import { getHtmlNodeAttribute, analyzeLinkNode, parseSrcSet } from "@jsenv/ast"
+import { getHtmlNodeAttribute, analyzeLinkNode, parseSrcSet } from "@jsenv/ast";
 
 // Some "smart" default applied to decide what should hot reload / fullreload:
 // By default:
@@ -8,7 +8,7 @@ import { getHtmlNodeAttribute, analyzeLinkNode, parseSrcSet } from "@jsenv/ast"
 //   - fullreload on <img src="./image.png" hot-decline />
 //   - hot reload on <script src="./file.js" hot-accept />
 export const collectHotDataFromHtmlAst = (htmlAst) => {
-  const hotReferences = []
+  const hotReferences = [];
 
   const onSpecifier = ({ specifier, node, attributeName, hotAccepted }) => {
     if (
@@ -19,115 +19,115 @@ export const collectHotDataFromHtmlAst = (htmlAst) => {
       hotReferences.push({
         type: `${node.nodeName}_${attributeName}`,
         specifier,
-      })
+      });
     }
-  }
+  };
 
   const visitUrlSpecifierAttribute = ({ node, attributeName, hotAccepted }) => {
-    const value = getHtmlNodeAttribute(node, attributeName)
+    const value = getHtmlNodeAttribute(node, attributeName);
     if (value) {
       onSpecifier({
         specifier: value,
         node,
         attributeName,
         hotAccepted,
-      })
+      });
     }
-  }
+  };
 
   const onNode = (node, { hotAccepted }) => {
     // explicitely disabled with [hot-decline] attribute
     if (hotAccepted === false) {
-      return
+      return;
     }
     if (nodeNamesWithHref.includes(node.nodeName)) {
       visitUrlSpecifierAttribute({
         node,
         attributeName: "href",
         hotAccepted,
-      })
+      });
       visitUrlSpecifierAttribute({
         node,
         attributeName: "inlined-from-href",
         hotAccepted,
-      })
+      });
     }
     if (nodeNamesWithSrc.includes(node.nodeName)) {
       visitUrlSpecifierAttribute({
         node,
         attributeName: "src",
         hotAccepted,
-      })
+      });
       visitUrlSpecifierAttribute({
         node,
         attributeName: "inlined-from-src",
         hotAccepted,
-      })
+      });
     }
     if (nodeNamesWithSrcset.includes(node.nodeName)) {
-      const srcset = getHtmlNodeAttribute(node, "srcset")
+      const srcset = getHtmlNodeAttribute(node, "srcset");
       if (srcset) {
-        const srcCandidates = parseSrcSet(srcset)
+        const srcCandidates = parseSrcSet(srcset);
         srcCandidates.forEach((srcCandidate) => {
           onSpecifier({
             node,
             specifier: srcCandidate.specifier,
             attributeName: "srcset",
             hotAccepted,
-          })
-        })
+          });
+        });
       }
     }
-  }
+  };
 
   const iterate = (node, context) => {
     context = {
       ...context,
       ...getNodeContext(node),
-    }
-    onNode(node, context)
-    const { childNodes } = node
+    };
+    onNode(node, context);
+    const { childNodes } = node;
     if (childNodes) {
-      let i = 0
+      let i = 0;
       while (i < childNodes.length) {
-        const childNode = childNodes[i++]
-        iterate(childNode, context)
+        const childNode = childNodes[i++];
+        iterate(childNode, context);
       }
     }
-  }
-  iterate(htmlAst, {})
+  };
+  iterate(htmlAst, {});
 
-  return hotReferences
-}
+  return hotReferences;
+};
 
-const nodeNamesWithHref = ["link", "a", "image", "use"]
-const nodeNamesWithSrc = ["script", "iframe", "img"]
-const nodeNamesWithSrcset = ["img", "source"]
+const nodeNamesWithHref = ["link", "a", "image", "use"];
+const nodeNamesWithSrc = ["script", "iframe", "img"];
+const nodeNamesWithSrcset = ["img", "source"];
 
 const getNodeContext = (node) => {
-  const context = {}
-  const hotAccept = getHtmlNodeAttribute(node, "hot-accept")
+  const context = {};
+  const hotAccept = getHtmlNodeAttribute(node, "hot-accept");
   if (hotAccept !== undefined) {
-    context.hotAccepted = true
+    context.hotAccepted = true;
   }
-  const hotDecline = getHtmlNodeAttribute(node, "hot-decline")
+  const hotDecline = getHtmlNodeAttribute(node, "hot-decline");
   if (hotDecline !== undefined) {
-    context.hotAccepted = false
+    context.hotAccepted = false;
   }
-  return context
-}
+  return context;
+};
 
 const htmlNodeCanHotReload = (node) => {
   if (node.nodeName === "link") {
-    const { isStylesheet, isResourceHint, rel } = analyzeLinkNode(node)
+    const { isStylesheet, isResourceHint, rel } = analyzeLinkNode(node);
     if (isStylesheet) {
       // stylesheets can be hot replaced by default
-      return true
+      return true;
     }
     if (isResourceHint) {
-      return false
+      return false;
     }
-    return rel === "icon"
+    return rel === "icon";
   }
   return [
     // "script", // script cannot hot reload
@@ -144,5 +144,5 @@ const htmlNodeCanHotReload = (node) => {
     "source",
     "image",
     "use",
-  ].includes(node.nodeName)
-}
+  ].includes(node.nodeName);
+};

package/src/plugins/import_meta_hot/jsenv_plugin_import_meta_hot.js

@@ -1,14 +1,14 @@
-import { createMagicSource } from "@jsenv/sourcemap"
-import { parseHtmlString, applyBabelPlugins } from "@jsenv/ast"
+import { createMagicSource } from "@jsenv/sourcemap";
+import { parseHtmlString, applyBabelPlugins } from "@jsenv/ast";
 
-import { collectHotDataFromHtmlAst } from "./html_hot_dependencies.js"
-import { babelPluginMetadataImportMetaHot } from "./babel_plugin_metadata_import_meta_hot.js"
+import { collectHotDataFromHtmlAst } from "./html_hot_dependencies.js";
+import { babelPluginMetadataImportMetaHot } from "./babel_plugin_metadata_import_meta_hot.js";
 
 export const jsenvPluginImportMetaHot = () => {
   const importMetaHotClientFileUrl = new URL(
     "./client/import_meta_hot.js",
     import.meta.url,
-  ).href
+  ).href;
 
   return {
     name: "jsenv:import_meta_hot",
@@ -17,12 +17,12 @@ export const jsenvPluginImportMetaHot = () => {
       html: (htmlUrlInfo, context) => {
         // during build we don't really care to parse html hot dependencies
         if (context.build) {
-          return
+          return;
         }
-        const htmlAst = parseHtmlString(htmlUrlInfo.content)
-        const hotReferences = collectHotDataFromHtmlAst(htmlAst)
-        htmlUrlInfo.data.hotDecline = false
-        htmlUrlInfo.data.hotAcceptSelf = false
+        const htmlAst = parseHtmlString(htmlUrlInfo.content);
+        const hotReferences = collectHotDataFromHtmlAst(htmlAst);
+        htmlUrlInfo.data.hotDecline = false;
+        htmlUrlInfo.data.hotAcceptSelf = false;
         htmlUrlInfo.data.hotAcceptDependencies = hotReferences.map(
           ({ type, specifier }) => {
             const existingReference = context.referenceUtils.find(
@@ -30,65 +30,69 @@ export const jsenvPluginImportMetaHot = () => {
                 return (
                   existingReference.type === type &&
                   existingReference.specifier === specifier
-                )
+                );
               },
-            )
+            );
             if (existingReference) {
-              return existingReference.url
+              return existingReference.url;
             }
             const [reference] = context.referenceUtils.found({
               type,
               specifier,
-            })
-            return reference.url
+            });
+            return reference.url;
           },
-        )
+        );
       },
       css: (cssUrlInfo) => {
-        cssUrlInfo.data.hotDecline = false
-        cssUrlInfo.data.hotAcceptSelf = false
-        cssUrlInfo.data.hotAcceptDependencies = []
+        cssUrlInfo.data.hotDecline = false;
+        cssUrlInfo.data.hotAcceptSelf = false;
+        cssUrlInfo.data.hotAcceptDependencies = [];
       },
       js_module: async (urlInfo, context) => {
         if (!urlInfo.content.includes("import.meta.hot")) {
-          return null
+          return null;
         }
         const { metadata } = await applyBabelPlugins({
           babelPlugins: [babelPluginMetadataImportMetaHot],
           urlInfo,
-        })
+        });
         const {
           importMetaHotPaths,
           hotDecline,
           hotAcceptSelf,
           hotAcceptDependencies,
-        } = metadata
-        urlInfo.data.hotDecline = hotDecline
-        urlInfo.data.hotAcceptSelf = hotAcceptSelf
-        urlInfo.data.hotAcceptDependencies = hotAcceptDependencies
+        } = metadata;
+        urlInfo.data.hotDecline = hotDecline;
+        urlInfo.data.hotAcceptSelf = hotAcceptSelf;
+        urlInfo.data.hotAcceptDependencies = hotAcceptDependencies;
         if (importMetaHotPaths.length === 0) {
-          return null
+          return null;
         }
         if (context.build) {
-          return removeImportMetaHots(urlInfo, importMetaHotPaths)
+          return removeImportMetaHots(urlInfo, importMetaHotPaths);
         }
-        return injectImportMetaHot(urlInfo, context, importMetaHotClientFileUrl)
+        return injectImportMetaHot(
+          urlInfo,
+          context,
+          importMetaHotClientFileUrl,
+        );
       },
     },
-  }
-}
+  };
+};
 
 const removeImportMetaHots = (urlInfo, importMetaHotPaths) => {
-  const magicSource = createMagicSource(urlInfo.content)
+  const magicSource = createMagicSource(urlInfo.content);
   importMetaHotPaths.forEach((path) => {
     magicSource.replace({
       start: path.node.start,
       end: path.node.end,
       replacement: "undefined",
-    })
-  })
-  return magicSource.toContentAndSourcemap()
-}
+    });
+  });
+  return magicSource.toContentAndSourcemap();
+};
 
 // For some reason using magic source here produce
 // better sourcemap than doing the equivalent with babel
@@ -100,12 +104,12 @@ const injectImportMetaHot = (urlInfo, context, importMetaHotClientFileUrl) => {
     type: "js_import",
     expectedType: "js_module",
     specifier: importMetaHotClientFileUrl,
-  })
-  const magicSource = createMagicSource(urlInfo.content)
+  });
+  const magicSource = createMagicSource(urlInfo.content);
   magicSource.prepend(
     `import { createImportMetaHot } from ${importMetaHotClientFileReference.generatedSpecifier}
 import.meta.hot = createImportMetaHot(import.meta.url)
 `,
-  )
-  return magicSource.toContentAndSourcemap()
-}
+  );
+  return magicSource.toContentAndSourcemap();
+};