@jsenv/core 35.0.2 → 35.0.4

package/src/plugins/autoreload/jsenv_plugin_autoreload_server.js

@@ -2,7 +2,7 @@ import {
   urlIsInsideOf,
   urlToRelativeUrl,
   asUrlWithoutSearch,
-} from "@jsenv/urls"
+} from "@jsenv/urls";
 
 export const jsenvPluginAutoreloadServer = ({
   clientFileChangeCallbackList,
@@ -15,13 +15,13 @@ export const jsenvPluginAutoreloadServer = ({
       reload: ({ sendServerEvent, rootDirectoryUrl, urlGraph }) => {
         const formatUrlForClient = (url) => {
           if (urlIsInsideOf(url, rootDirectoryUrl)) {
-            return urlToRelativeUrl(url, rootDirectoryUrl)
+            return urlToRelativeUrl(url, rootDirectoryUrl);
           }
           if (url.startsWith("file:")) {
-            return `/@fs/${url.slice("file:///".length)}`
+            return `/@fs/${url.slice("file:///".length)}`;
           }
-          return url
-        }
+          return url;
+        };
 
         const notifyDeclined = ({ cause, reason, declinedBy }) => {
           sendServerEvent({
@@ -29,22 +29,22 @@ export const jsenvPluginAutoreloadServer = ({
             type: "full",
             typeReason: reason,
             declinedBy,
-          })
-        }
+          });
+        };
         const notifyAccepted = ({ cause, reason, instructions }) => {
           sendServerEvent({
             cause,
             type: "hot",
             typeReason: reason,
             hotInstructions: instructions,
-          })
-        }
+          });
+        };
         const propagateUpdate = (firstUrlInfo) => {
           if (!urlGraph.getUrlInfo(firstUrlInfo.url)) {
             return {
               declined: true,
               reason: `url not in the url graph`,
-            }
+            };
           }
           const iterate = (urlInfo, seen) => {
             if (urlInfo.data.hotAcceptSelf) {
@@ -61,48 +61,48 @@ export const jsenvPluginAutoreloadServer = ({
                     acceptedBy: formatUrlForClient(urlInfo.url),
                   },
                 ],
-              }
+              };
             }
-            const { dependents } = urlInfo
-            const instructions = []
+            const { dependents } = urlInfo;
+            const instructions = [];
             for (const dependentUrl of dependents) {
-              const dependentUrlInfo = urlGraph.getUrlInfo(dependentUrl)
+              const dependentUrlInfo = urlGraph.getUrlInfo(dependentUrl);
               if (dependentUrlInfo.data.hotDecline) {
                 return {
                   declined: true,
                   reason: `a dependent file declines hot reload`,
                   declinedBy: dependentUrl,
-                }
+                };
               }
-              const { hotAcceptDependencies = [] } = dependentUrlInfo.data
+              const { hotAcceptDependencies = [] } = dependentUrlInfo.data;
               if (hotAcceptDependencies.includes(urlInfo.url)) {
                 instructions.push({
                   type: dependentUrlInfo.type,
                   boundary: formatUrlForClient(dependentUrl),
                   acceptedBy: formatUrlForClient(urlInfo.url),
-                })
-                continue
+                });
+                continue;
               }
               if (seen.includes(dependentUrl)) {
                 return {
                   declined: true,
                   reason: "circular dependency",
                   declinedBy: formatUrlForClient(dependentUrl),
-                }
+                };
               }
               const dependentPropagationResult = iterate(dependentUrlInfo, [
                 ...seen,
                 dependentUrl,
-              ])
+              ]);
               if (dependentPropagationResult.accepted) {
-                instructions.push(...dependentPropagationResult.instructions)
-                continue
+                instructions.push(...dependentPropagationResult.instructions);
+                continue;
               }
               if (
                 // declined explicitely by an other file, it must decline the whole update
                 dependentPropagationResult.declinedBy
               ) {
-                return dependentPropagationResult
+                return dependentPropagationResult;
               }
               // declined by absence of boundary, we can keep searching
             }
@@ -110,52 +110,53 @@ export const jsenvPluginAutoreloadServer = ({
               return {
                 declined: true,
                 reason: `there is no file accepting hot reload while propagating update`,
-              }
+              };
             }
             return {
               accepted: true,
               reason: `${instructions.length} dependent file(s) accepts hot reload`,
               instructions,
-            }
-          }
-          const seen = []
-          return iterate(firstUrlInfo, seen)
-        }
+            };
+          };
+          const seen = [];
+          return iterate(firstUrlInfo, seen);
+        };
         clientFileChangeCallbackList.push(({ url, event }) => {
           const onUrlInfo = (urlInfo) => {
-            const relativeUrl = formatUrlForClient(urlInfo.url)
-            const hotUpdate = propagateUpdate(urlInfo)
+            const relativeUrl = formatUrlForClient(urlInfo.url);
+            const hotUpdate = propagateUpdate(urlInfo);
             if (hotUpdate.declined) {
               notifyDeclined({
                 cause: `${relativeUrl} ${event}`,
                 reason: hotUpdate.reason,
                 declinedBy: hotUpdate.declinedBy,
-              })
+              });
             } else {
               notifyAccepted({
                 cause: `${relativeUrl} ${event}`,
                 reason: hotUpdate.reason,
                 instructions: hotUpdate.instructions,
-              })
+              });
             }
-          }
-          const exactUrlInfo = urlGraph.getUrlInfo(url)
+          };
+          const exactUrlInfo = urlGraph.getUrlInfo(url);
           if (exactUrlInfo) {
-            onUrlInfo(exactUrlInfo)
+            onUrlInfo(exactUrlInfo);
           }
           urlGraph.urlInfoMap.forEach((urlInfo) => {
-            if (urlInfo === exactUrlInfo) return
-            const urlWithoutSearch = asUrlWithoutSearch(urlInfo.url)
-            if (urlWithoutSearch !== url) return
-            if (exactUrlInfo && exactUrlInfo.dependents.has(urlInfo.url)) return
-            onUrlInfo(urlInfo)
-          })
-        })
+            if (urlInfo === exactUrlInfo) return;
+            const urlWithoutSearch = asUrlWithoutSearch(urlInfo.url);
+            if (urlWithoutSearch !== url) return;
+            if (exactUrlInfo && exactUrlInfo.dependents.has(urlInfo.url))
+              return;
+            onUrlInfo(urlInfo);
+          });
+        });
         clientFilesPruneCallbackList.push((prunedUrlInfos, firstUrlInfo) => {
-          const mainHotUpdate = propagateUpdate(firstUrlInfo)
+          const mainHotUpdate = propagateUpdate(firstUrlInfo);
           const cause = `following files are no longer referenced: ${prunedUrlInfos.map(
             (prunedUrlInfo) => formatUrlForClient(prunedUrlInfo.url),
-          )}`
+          )}`;
           // now check if we can hot update the main resource
           // then if we can hot update all dependencies
           if (mainHotUpdate.declined) {
@@ -163,39 +164,39 @@ export const jsenvPluginAutoreloadServer = ({
               cause,
               reason: mainHotUpdate.reason,
               declinedBy: mainHotUpdate.declinedBy,
-            })
-            return
+            });
+            return;
           }
           // main can hot update
-          let i = 0
-          const instructions = []
+          let i = 0;
+          const instructions = [];
           while (i < prunedUrlInfos.length) {
-            const prunedUrlInfo = prunedUrlInfos[i++]
+            const prunedUrlInfo = prunedUrlInfos[i++];
             if (prunedUrlInfo.data.hotDecline) {
               notifyDeclined({
                 cause,
                 reason: `a pruned file declines hot reload`,
                 declinedBy: formatUrlForClient(prunedUrlInfo.url),
-              })
-              return
+              });
+              return;
             }
             instructions.push({
               type: "prune",
               boundary: formatUrlForClient(prunedUrlInfo.url),
               acceptedBy: formatUrlForClient(firstUrlInfo.url),
-            })
+            });
           }
           notifyAccepted({
             cause,
             reason: mainHotUpdate.reason,
             instructions,
-          })
-        })
+          });
+        });
       },
     },
     serve: (request, { rootDirectoryUrl, urlGraph }) => {
       if (request.pathname === "/__graph__") {
-        const graphJson = JSON.stringify(urlGraph.toJSON(rootDirectoryUrl))
+        const graphJson = JSON.stringify(urlGraph.toJSON(rootDirectoryUrl));
         return {
           status: 200,
           headers: {
@@ -203,9 +204,9 @@ export const jsenvPluginAutoreloadServer = ({
             "content-length": Buffer.byteLength(graphJson),
           },
           body: graphJson,
-        }
+        };
       }
-      return null
+      return null;
     },
-  }
-}
+  };
+};

package/src/plugins/autoreload/jsenv_plugin_hmr.js

@@ -4,40 +4,40 @@ export const jsenvPluginHmr = () => {
     appliesDuring: "dev",
     redirectUrl: (reference) => {
       if (!reference.searchParams.has("hmr")) {
-        reference.data.hmr = false
-        return null
+        reference.data.hmr = false;
+        return null;
       }
-      reference.data.hmr = true
-      const urlObject = new URL(reference.url)
+      reference.data.hmr = true;
+      const urlObject = new URL(reference.url);
       // "hmr" search param goal is to mark url as enabling hmr:
       // 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)
-      urlObject.searchParams.delete("hmr")
-      urlObject.searchParams.delete("v")
-      return urlObject.href
+      urlObject.searchParams.delete("hmr");
+      urlObject.searchParams.delete("v");
+      return urlObject.href;
     },
     transformUrlSearchParams: (reference, context) => {
       if (reference.type === "package_json") {
         // maybe the if above shoulb be .isImplicit but it's just a detail anyway
-        return null
+        return null;
       }
       if (context.reference && !context.reference.data.hmr) {
         // parent do not use hmr search param
-        return null
+        return null;
       }
       if (!context.reference && !reference.data.hmr) {
         // entry point do not use hmr search param
-        return null
+        return null;
       }
-      const urlInfo = context.urlGraph.getUrlInfo(reference.url)
+      const urlInfo = context.urlGraph.getUrlInfo(reference.url);
       if (!urlInfo.modifiedTimestamp) {
-        return null
+        return null;
       }
       return {
         hmr: "",
         v: urlInfo.modifiedTimestamp,
-      }
+      };
     },
-  }
-}
+  };
+};

package/src/plugins/cache_control/jsenv_plugin_cache_control.js

@@ -15,11 +15,11 @@ export const jsenvPluginCacheControl = ({
           headers: {
             "cache-control": `private,max-age=${maxAge},immutable`,
           },
-        }
+        };
       }
-      return null
+      return null;
     },
-  }
-}
+  };
+};
 
-const SECONDS_IN_30_DAYS = 60 * 60 * 24 * 30
+const SECONDS_IN_30_DAYS = 60 * 60 * 24 * 30;

package/src/plugins/commonjs_globals/jsenv_plugin_commonjs_globals.js

@@ -7,8 +7,8 @@
  * - global
  */
 
-import { createMagicSource } from "@jsenv/sourcemap"
-import { applyBabelPlugins } from "@jsenv/ast"
+import { createMagicSource } from "@jsenv/sourcemap";
+import { applyBabelPlugins } from "@jsenv/ast";
 
 export const jsenvPluginCommonJsGlobals = () => {
   const transformCommonJsGlobals = async (urlInfo, context) => {
@@ -17,9 +17,9 @@ export const jsenvPluginCommonJsGlobals = () => {
       !urlInfo.content.includes("__filename") &&
       !urlInfo.content.includes("__dirname")
     ) {
-      return null
+      return null;
     }
-    const isJsModule = urlInfo.type === "js_module"
+    const isJsModule = urlInfo.type === "js_module";
     const replaceMap = {
       "process.env.NODE_ENV": `("${
         context.dev ? "development" : "production"
@@ -31,7 +31,7 @@ export const jsenvPluginCommonJsGlobals = () => {
       "__dirname": isJsModule
         ? `import.meta.url.slice('file:///'.length).replace(/[\\\/\\\\][^\\\/\\\\]*$/, '')`
         : `new URL('./', document.currentScript.src).href`,
-    }
+    };
     const { metadata } = await applyBabelPlugins({
       babelPlugins: [
         [
@@ -43,24 +43,24 @@ export const jsenvPluginCommonJsGlobals = () => {
         ],
       ],
       urlInfo,
-    })
-    const { expressionPaths } = metadata
-    const keys = Object.keys(expressionPaths)
+    });
+    const { expressionPaths } = metadata;
+    const keys = Object.keys(expressionPaths);
     if (keys.length === 0) {
-      return null
+      return null;
     }
-    const magicSource = createMagicSource(urlInfo.content)
+    const magicSource = createMagicSource(urlInfo.content);
     keys.forEach((key) => {
       expressionPaths[key].forEach((path) => {
         magicSource.replace({
           start: path.node.start,
           end: path.node.end,
           replacement: replaceMap[key],
-        })
-      })
-    })
-    return magicSource.toContentAndSourcemap()
-  }
+        });
+      });
+    });
+    return magicSource.toContentAndSourcemap();
+  };
 
   return {
     name: "jsenv:commonjs_globals",
@@ -69,8 +69,8 @@ export const jsenvPluginCommonJsGlobals = () => {
       js_classic: transformCommonJsGlobals,
       js_module: transformCommonJsGlobals,
     },
-  }
-}
+  };
+};
 
 // heavily inspired from https://github.com/jviide/babel-plugin-transform-replace-expressions
 // last known commit: 57b608e0eeb8807db53d1c68292621dfafb5599c
@@ -78,9 +78,9 @@ const babelPluginMetadataExpressionPaths = (
   babel,
   { replaceMap = {}, allowConflictingReplacements = false },
 ) => {
-  const { traverse, parse, types } = babel
-  const replacementMap = new Map()
-  const valueExpressionSet = new Set()
+  const { traverse, parse, types } = babel;
+  const replacementMap = new Map();
+  const valueExpressionSet = new Set();
 
   return {
     name: "metadata-replace",
@@ -89,94 +89,94 @@ const babelPluginMetadataExpressionPaths = (
       // https://github.com/babel/babel/blob/d50e78d45b608f6e0f6cc33aeb22f5db5027b153/packages/babel-traverse/src/path/replacement.js#L93
       const parseExpression = (value) => {
         const expressionNode = parse(value, state.opts).program.body[0]
-          .expression
-        traverse.removeProperties(expressionNode)
-        return expressionNode
-      }
+          .expression;
+        traverse.removeProperties(expressionNode);
+        return expressionNode;
+      };
       Object.keys(replaceMap).forEach((key) => {
-        const keyExpressionNode = parseExpression(key)
-        const candidateArray = replacementMap.get(keyExpressionNode.type) || []
-        const value = replaceMap[key]
-        const valueExpressionNode = parseExpression(value)
+        const keyExpressionNode = parseExpression(key);
+        const candidateArray = replacementMap.get(keyExpressionNode.type) || [];
+        const value = replaceMap[key];
+        const valueExpressionNode = parseExpression(value);
         const equivalentKeyExpressionIndex = candidateArray.findIndex(
           (candidate) =>
             types.isNodesEquivalent(
               candidate.keyExpressionNode,
               keyExpressionNode,
             ),
-        )
+        );
         if (
           !allowConflictingReplacements &&
           equivalentKeyExpressionIndex > -1
         ) {
           throw new Error(
             `Expressions ${candidateArray[equivalentKeyExpressionIndex].key} and ${key} conflict`,
-          )
+          );
         }
         const newCandidate = {
           key,
           value,
           keyExpressionNode,
           valueExpressionNode,
-        }
+        };
         if (equivalentKeyExpressionIndex > -1) {
-          candidateArray[equivalentKeyExpressionIndex] = newCandidate
+          candidateArray[equivalentKeyExpressionIndex] = newCandidate;
         } else {
-          candidateArray.push(newCandidate)
+          candidateArray.push(newCandidate);
         }
-        replacementMap.set(keyExpressionNode.type, candidateArray)
-      })
+        replacementMap.set(keyExpressionNode.type, candidateArray);
+      });
       replacementMap.forEach((candidateArray) => {
         candidateArray.forEach((candidate) => {
-          valueExpressionSet.add(candidate.valueExpressionNode)
-        })
-      })
+          valueExpressionSet.add(candidate.valueExpressionNode);
+        });
+      });
     },
     visitor: {
       Program: (programPath, state) => {
-        const expressionPaths = {}
+        const expressionPaths = {};
         programPath.traverse({
           Expression(path) {
             if (valueExpressionSet.has(path.node)) {
-              path.skip()
-              return
+              path.skip();
+              return;
             }
-            const candidateArray = replacementMap.get(path.node.type)
+            const candidateArray = replacementMap.get(path.node.type);
             if (!candidateArray) {
-              return
+              return;
             }
             const candidateFound = candidateArray.find((candidate) => {
               return types.isNodesEquivalent(
                 candidate.keyExpressionNode,
                 path.node,
-              )
-            })
+              );
+            });
             if (candidateFound) {
               try {
                 types.validate(
                   path.parent,
                   path.key,
                   candidateFound.valueExpressionNode,
-                )
+                );
               } catch (err) {
                 if (err instanceof TypeError) {
-                  path.skip()
-                  return
+                  path.skip();
+                  return;
                 }
-                throw err
+                throw err;
               }
-              const paths = expressionPaths[candidateFound.key]
+              const paths = expressionPaths[candidateFound.key];
               if (paths) {
-                expressionPaths[candidateFound.key] = [...paths, path]
+                expressionPaths[candidateFound.key] = [...paths, path];
               } else {
-                expressionPaths[candidateFound.key] = [path]
+                expressionPaths[candidateFound.key] = [path];
               }
-              return
+              return;
             }
           },
-        })
-        state.file.metadata.expressionPaths = expressionPaths
+        });
+        state.file.metadata.expressionPaths = expressionPaths;
       },
     },
-  }
-}
+  };
+};