@jsenv/core 35.0.3 → 35.0.5

package/src/plugins/explorer/client/explorer.html

@@ -368,7 +368,7 @@
     </div>
     <script no-supervisor>
       // eslint-disable-next-line no-undef
-      const { rootDirectoryUrl, groups, files } = SERVER_PARAMS
+      const { rootDirectoryUrl, groups, files } = SERVER_PARAMS;
 
       const groupPreference = {
         has: () => localStorage.hasOwnProperty("explorer_active_group"),
@@ -378,30 +378,30 @@
             : undefined,
         set: (value) =>
           localStorage.setItem("explorer_active_group", JSON.stringify(value)),
-      }
+      };
       const directoryNameFromUrl = (directoryUrl) => {
         const slashLastIndex = directoryUrl.lastIndexOf(
           "/",
           // ignore last slash
           directoryUrl.length - 2,
-        )
-        if (slashLastIndex === -1) return ""
-        return directoryUrl.slice(slashLastIndex + 1)
-      }
+        );
+        if (slashLastIndex === -1) return "";
+        return directoryUrl.slice(slashLastIndex + 1);
+      };
       const urlToVisitFromRelativeUrl = (relativeUrl) => {
-        return `${window.origin}/${relativeUrl}`
-      }
+        return `${window.origin}/${relativeUrl}`;
+      };
 
       const fileListElement = document
         .querySelector(`[data-page="file-list"]`)
-        .cloneNode(true)
-      const directoryName = directoryNameFromUrl(rootDirectoryUrl)
-      const span = fileListElement.querySelector("#directory_relative_url")
-      span.title = rootDirectoryUrl
-      span.textContent = directoryName
-
-      const h4 = fileListElement.querySelector("h4")
-      const ul = fileListElement.querySelector("ul")
+        .cloneNode(true);
+      const directoryName = directoryNameFromUrl(rootDirectoryUrl);
+      const span = fileListElement.querySelector("#directory_relative_url");
+      span.title = rootDirectoryUrl;
+      span.textContent = directoryName;
+
+      const h4 = fileListElement.querySelector("h4");
+      const ul = fileListElement.querySelector("ul");
       ul.innerHTML = files
         .map(
           (file) =>
@@ -415,10 +415,10 @@
         </a>
       </li>`,
         )
-        .join("")
+        .join("");
 
-      const groupFieldset = fileListElement.querySelector("#filter-group-set")
-      const groupNames = Object.keys(groups)
+      const groupFieldset = fileListElement.querySelector("#filter-group-set");
+      const groupNames = Object.keys(groups);
       groupFieldset.innerHTML = groupNames
         .map(
           (key) => `<label data-contains-hidden-input class="item">
@@ -426,45 +426,45 @@
         <span>${key}</span>
       </label>`,
         )
-        .join("")
+        .join("");
 
-      const groupFromLocalStorage = groupPreference.get()
+      const groupFromLocalStorage = groupPreference.get();
       const currentGroup =
         groupFromLocalStorage && groupNames.includes(groupFromLocalStorage)
           ? groupFromLocalStorage
-          : groupNames[0]
+          : groupNames[0];
       Array.from(groupFieldset.querySelectorAll("input")).forEach(
         (inputRadio) => {
-          inputRadio.checked = inputRadio.value === currentGroup
+          inputRadio.checked = inputRadio.value === currentGroup;
           inputRadio.onchange = () => {
             if (inputRadio.checked) {
-              groupPreference.set(inputRadio.value)
-              enableGroup(inputRadio.value)
+              groupPreference.set(inputRadio.value);
+              enableGroup(inputRadio.value);
             }
-          }
+          };
         },
-      )
+      );
 
       const enableGroup = (groupName) => {
-        const arrayOfElementToShow = []
-        const arrayOfElementToHide = []
+        const arrayOfElementToShow = [];
+        const arrayOfElementToHide = [];
         files.forEach((file) => {
           const fileLink = fileListElement.querySelector(
             `a[data-relative-url="${file.relativeUrl}"]`,
-          )
-          const fileLi = fileLink.parentNode
+          );
+          const fileLi = fileLink.parentNode;
           if (file.meta[groupName]) {
-            arrayOfElementToShow.push(fileLi)
+            arrayOfElementToShow.push(fileLi);
           } else {
-            arrayOfElementToHide.push(fileLi)
+            arrayOfElementToHide.push(fileLi);
           }
-        })
+        });
         arrayOfElementToShow.forEach((element) => {
-          element.removeAttribute("data-force-hide")
-        })
+          element.removeAttribute("data-force-hide");
+        });
         arrayOfElementToHide.forEach((element) => {
-          element.setAttribute("data-force-hide", "")
-        })
+          element.setAttribute("data-force-hide", "");
+        });
 
         h4.innerHTML =
           arrayOfElementToShow.length === 0
@@ -474,65 +474,65 @@
         null,
         "  ",
       )}</pre>`
-            : `${arrayOfElementToShow.length} files found. Click on the one you want to execute`
-      }
-      enableGroup(currentGroup)
+            : `${arrayOfElementToShow.length} files found. Click on the one you want to execute`;
+      };
+      enableGroup(currentGroup);
 
-      document.querySelector("main").appendChild(fileListElement)
+      document.querySelector("main").appendChild(fileListElement);
     </script>
     <script no-supervisor>
       // make menu scrollable
       const getMenuWrapperSize = () => {
         return document.querySelector(".menu-wrapper").getBoundingClientRect()
-          .width
-      }
+          .width;
+      };
       const getMenuSize = () => {
-        return document.querySelector(".menu").getBoundingClientRect().width
-      }
+        return document.querySelector(".menu").getBoundingClientRect().width;
+      };
       const getMenuPosition = () => {
-        return document.querySelector(".menu-wrapper").scrollLeft
-      }
+        return document.querySelector(".menu-wrapper").scrollLeft;
+      };
 
-      let menuWrapperSize = getMenuWrapperSize()
-      let menuSize = getMenuSize()
-      const menuVisibleSize = menuWrapperSize
-      let menuInvisibleSize = menuSize - menuVisibleSize
-      const scrollDuration = 300
-      const leftPaddle = document.querySelector(".left-paddle")
-      const rightPaddle = document.querySelector(".right-paddle")
+      let menuWrapperSize = getMenuWrapperSize();
+      let menuSize = getMenuSize();
+      const menuVisibleSize = menuWrapperSize;
+      let menuInvisibleSize = menuSize - menuVisibleSize;
+      const scrollDuration = 300;
+      const leftPaddle = document.querySelector(".left-paddle");
+      const rightPaddle = document.querySelector(".right-paddle");
 
       const handleMenuScroll = () => {
-        menuInvisibleSize = menuSize - menuWrapperSize
-        const menuPosition = getMenuPosition()
-        const menuEndOffset = menuInvisibleSize
+        menuInvisibleSize = menuSize - menuWrapperSize;
+        const menuPosition = getMenuPosition();
+        const menuEndOffset = menuInvisibleSize;
         // show & hide the paddles, depending on scroll position
         if (menuPosition <= 0 && menuEndOffset <= 0) {
           // hide both paddles if the window is large enough to display all tabs
-          leftPaddle.classList.add("hidden")
-          rightPaddle.classList.add("hidden")
+          leftPaddle.classList.add("hidden");
+          rightPaddle.classList.add("hidden");
         } else if (menuPosition <= 0) {
-          leftPaddle.classList.add("hidden")
-          rightPaddle.classList.remove("hidden")
+          leftPaddle.classList.add("hidden");
+          rightPaddle.classList.remove("hidden");
         } else if (menuPosition < Math.floor(menuEndOffset)) {
           // show both paddles in the middle
-          leftPaddle.classList.remove("hidden")
-          rightPaddle.classList.remove("hidden")
+          leftPaddle.classList.remove("hidden");
+          rightPaddle.classList.remove("hidden");
         } else if (menuPosition >= Math.floor(menuEndOffset)) {
-          leftPaddle.classList.remove("hidden")
-          rightPaddle.classList.add("hidden")
+          leftPaddle.classList.remove("hidden");
+          rightPaddle.classList.add("hidden");
         }
-      }
-      handleMenuScroll()
+      };
+      handleMenuScroll();
 
       window.onresize = () => {
-        menuWrapperSize = getMenuWrapperSize()
-        menuSize = getMenuSize()
-        handleMenuScroll()
-      }
+        menuWrapperSize = getMenuWrapperSize();
+        menuSize = getMenuSize();
+        handleMenuScroll();
+      };
       // finally, what happens when we are actually scrolling the menu
       document.querySelector(".menu-wrapper").onscroll = () => {
-        handleMenuScroll()
-      }
+        handleMenuScroll();
+      };
 
       const startJavaScriptAnimation = ({
         duration = 300,
@@ -541,68 +541,68 @@
         onCancel = () => {},
         onComplete = () => {},
       }) => {
-        duration = parseInt(duration, 10)
-        const startMs = performance.now()
-        let currentRequestAnimationFrameId
-        let done = false
-        let rawProgress = 0
-        let progress = 0
+        duration = parseInt(duration, 10);
+        const startMs = performance.now();
+        let currentRequestAnimationFrameId;
+        let done = false;
+        let rawProgress = 0;
+        let progress = 0;
         const handler = () => {
-          currentRequestAnimationFrameId = null
-          const nowMs = performance.now()
-          rawProgress = Math.min((nowMs - startMs) / duration, 1)
-          progress = timingFunction(rawProgress)
-          done = rawProgress === 1
+          currentRequestAnimationFrameId = null;
+          const nowMs = performance.now();
+          rawProgress = Math.min((nowMs - startMs) / duration, 1);
+          progress = timingFunction(rawProgress);
+          done = rawProgress === 1;
           onProgress({
             done,
             rawProgress,
             progress,
-          })
+          });
           if (done) {
-            onComplete()
+            onComplete();
           } else {
             currentRequestAnimationFrameId =
-              window.requestAnimationFrame(handler)
+              window.requestAnimationFrame(handler);
           }
-        }
-        handler()
+        };
+        handler();
         const stop = () => {
           if (currentRequestAnimationFrameId) {
-            window.cancelAnimationFrame(currentRequestAnimationFrameId)
-            currentRequestAnimationFrameId = null
+            window.cancelAnimationFrame(currentRequestAnimationFrameId);
+            currentRequestAnimationFrameId = null;
           }
           if (!done) {
-            done = true
+            done = true;
             onCancel({
               rawProgress,
               progress,
-            })
+            });
           }
-        }
-        return stop
-      }
+        };
+        return stop;
+      };
       rightPaddle.onclick = () => {
-        const scrollStart = document.querySelector(".menu-wrapper").scrollLeft
-        const scrollEnd = scrollStart + menuWrapperSize
+        const scrollStart = document.querySelector(".menu-wrapper").scrollLeft;
+        const scrollEnd = scrollStart + menuWrapperSize;
         startJavaScriptAnimation({
           duration: scrollDuration,
           onProgress: ({ progress }) => {
             document.querySelector(".menu-wrapper").scrollLeft =
-              scrollStart + (scrollEnd - scrollStart) * progress
+              scrollStart + (scrollEnd - scrollStart) * progress;
           },
-        })
-      }
+        });
+      };
       leftPaddle.onclick = () => {
-        const scrollStart = document.querySelector(".menu-wrapper").scrollLeft
-        const scrollEnd = scrollStart - menuWrapperSize
+        const scrollStart = document.querySelector(".menu-wrapper").scrollLeft;
+        const scrollEnd = scrollStart - menuWrapperSize;
         startJavaScriptAnimation({
           duration: scrollDuration,
           onProgress: ({ progress }) => {
             document.querySelector(".menu-wrapper").scrollLeft =
-              scrollStart + (scrollEnd - scrollStart) * progress
+              scrollStart + (scrollEnd - scrollStart) * progress;
           },
-        })
-      }
+        });
+      };
     </script>
   </body>
 </html>

package/src/plugins/explorer/jsenv_plugin_explorer.js

@@ -1,11 +1,11 @@
-import { readFileSync } from "node:fs"
-import { DATA_URL } from "@jsenv/urls"
-import { collectFiles } from "@jsenv/filesystem"
-import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
+import { readFileSync } from "node:fs";
+import { DATA_URL } from "@jsenv/urls";
+import { collectFiles } from "@jsenv/filesystem";
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
 
 export const explorerHtmlFileUrl = String(
   new URL("./client/explorer.html", import.meta.url),
-)
+);
 
 export const jsenvPluginExplorer = ({
   groups = {
@@ -18,7 +18,7 @@ export const jsenvPluginExplorer = ({
     },
   },
 }) => {
-  const faviconClientFileUrl = new URL("./client/jsenv.png", import.meta.url)
+  const faviconClientFileUrl = new URL("./client/jsenv.png", import.meta.url);
 
   return {
     name: "jsenv:explorer",
@@ -26,9 +26,9 @@ export const jsenvPluginExplorer = ({
     transformUrlContent: {
       html: async (urlInfo, context) => {
         if (urlInfo.url !== explorerHtmlFileUrl) {
-          return null
+          return null;
         }
-        let html = urlInfo.content
+        let html = urlInfo.content;
         if (html.includes("ignore:FAVICON_HREF")) {
           html = html.replace(
             "ignore:FAVICON_HREF",
@@ -39,29 +39,29 @@ export const jsenvPluginExplorer = ({
                 "base64",
               ),
             }),
-          )
+          );
         }
         if (html.includes("SERVER_PARAMS")) {
-          const associationsForExplorable = {}
+          const associationsForExplorable = {};
           Object.keys(groups).forEach((groupName) => {
-            const groupConfig = groups[groupName]
+            const groupConfig = groups[groupName];
             associationsForExplorable[groupName] = {
               "**/.jsenv/": false, // avoid visting .jsenv directory in jsenv itself
               ...groupConfig,
-            }
-          })
+            };
+          });
           const matchingFileResultArray = await collectFiles({
             directoryUrl: context.rootDirectoryUrl,
             associations: associationsForExplorable,
             predicate: (meta) =>
               Object.keys(meta).some((group) => Boolean(meta[group])),
-          })
+          });
           const files = matchingFileResultArray.map(
             ({ relativeUrl, meta }) => ({
               relativeUrl,
               meta,
             }),
-          )
+          );
 
           html = html.replace(
             "SERVER_PARAMS",
@@ -74,13 +74,13 @@ export const jsenvPluginExplorer = ({
               null,
               "  ",
             ),
-          )
+          );
           Object.assign(urlInfo.headers, {
             "cache-control": "no-store",
-          })
+          });
         }
-        return html
+        return html;
       },
     },
-  }
-}
+  };
+};

package/src/plugins/file_urls/jsenv_plugin_file_urls.js

@@ -1,16 +1,16 @@
-import { readFileSync, readdirSync, realpathSync, statSync } from "node:fs"
-import { pathToFileURL } from "node:url"
+import { readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { pathToFileURL } from "node:url";
 import {
   urlIsInsideOf,
   urlToRelativeUrl,
   urlToFilename,
   ensurePathnameTrailingSlash,
-} from "@jsenv/urls"
+} from "@jsenv/urls";
 import {
   applyFileSystemMagicResolution,
   getExtensionsToTry,
-} from "@jsenv/node-esm-resolution"
-import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
+} from "@jsenv/node-esm-resolution";
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
 
 export const jsenvPluginFileUrls = ({
   magicExtensions = ["inherit", ".js"],
@@ -25,38 +25,38 @@ export const jsenvPluginFileUrls = ({
       redirectUrl: (reference) => {
         // http, https, data, about, ...
         if (!reference.url.startsWith("file:")) {
-          return null
+          return null;
         }
         if (reference.isInline) {
-          return null
+          return null;
         }
-        const urlObject = new URL(reference.url)
-        let stat
+        const urlObject = new URL(reference.url);
+        let stat;
         try {
-          stat = statSync(urlObject)
+          stat = statSync(urlObject);
         } catch (e) {
           if (e.code === "ENOENT") {
-            stat = null
+            stat = null;
           } else {
-            throw e
+            throw e;
           }
         }
-        const { search, hash } = urlObject
-        let { pathname } = urlObject
-        const pathnameUsesTrailingSlash = pathname.endsWith("/")
-        urlObject.search = ""
-        urlObject.hash = ""
+        const { search, hash } = urlObject;
+        let { pathname } = urlObject;
+        const pathnameUsesTrailingSlash = pathname.endsWith("/");
+        urlObject.search = "";
+        urlObject.hash = "";
         // force trailing slash on directories
         if (stat && stat.isDirectory() && !pathnameUsesTrailingSlash) {
-          urlObject.pathname = `${pathname}/`
+          urlObject.pathname = `${pathname}/`;
         }
         // otherwise remove trailing slash if any
         if (stat && !stat.isDirectory() && pathnameUsesTrailingSlash) {
           // a warning here? (because it's strange to reference a file with a trailing slash)
-          urlObject.pathname = pathname.slice(0, -1)
+          urlObject.pathname = pathname.slice(0, -1);
         }
 
-        let url = urlObject.href
+        let url = urlObject.href;
         const shouldPreserve =
           stat &&
           stat.isDirectory() &&
@@ -65,13 +65,13 @@ export const jsenvPluginFileUrls = ({
             // ignore root file url
             reference.url === "file:///" ||
             (reference.subtype === "new_url_first_arg" &&
-              reference.specifier === "./"))
+              reference.specifier === "./"));
 
         if (shouldPreserve) {
-          reference.shouldHandle = false
+          reference.shouldHandle = false;
         } else {
           const shouldApplyDilesystemMagicResolution =
-            reference.type === "js_import"
+            reference.type === "js_import";
           if (shouldApplyDilesystemMagicResolution) {
             const filesystemResolution = applyFileSystemMagicResolution(url, {
               fileStat: stat,
@@ -80,10 +80,10 @@ export const jsenvPluginFileUrls = ({
                 magicExtensions,
                 reference.parentUrl,
               ),
-            })
+            });
             if (filesystemResolution.stat) {
-              stat = filesystemResolution.stat
-              url = filesystemResolution.url
+              stat = filesystemResolution.stat;
+              url = filesystemResolution.url;
             }
           }
           if (stat && stat.isDirectory()) {
@@ -91,21 +91,21 @@ export const jsenvPluginFileUrls = ({
               reference.type === "filesystem" ||
               (typeof directoryReferenceAllowed === "function" &&
                 directoryReferenceAllowed(reference)) ||
-              directoryReferenceAllowed
+              directoryReferenceAllowed;
             if (!directoryAllowed) {
-              const error = new Error("Reference leads to a directory")
-              error.code = "DIRECTORY_REFERENCE_NOT_ALLOWED"
-              throw error
+              const error = new Error("Reference leads to a directory");
+              error.code = "DIRECTORY_REFERENCE_NOT_ALLOWED";
+              throw error;
             }
           }
         }
-        reference.leadsToADirectory = stat && stat.isDirectory()
+        reference.leadsToADirectory = stat && stat.isDirectory();
         if (stat) {
-          const urlRaw = preserveSymlinks ? url : resolveSymlink(url)
-          const resolvedUrl = `${urlRaw}${search}${hash}`
-          return resolvedUrl
+          const urlRaw = preserveSymlinks ? url : resolveSymlink(url);
+          const resolvedUrl = `${urlRaw}${search}${hash}`;
+          return resolvedUrl;
         }
-        return null
+        return null;
       },
     },
     {
@@ -113,13 +113,13 @@ export const jsenvPluginFileUrls = ({
       appliesDuring: "*",
       resolveUrl: {
         filesystem: (reference, context) => {
-          const { parentUrl } = reference
-          const parentUrlInfo = context.urlGraph.getUrlInfo(parentUrl)
+          const { parentUrl } = reference;
+          const parentUrlInfo = context.urlGraph.getUrlInfo(parentUrl);
           const baseUrl =
             parentUrlInfo && parentUrlInfo.type === "directory"
               ? ensurePathnameTrailingSlash(parentUrl)
-              : parentUrl
-          return new URL(reference.specifier, baseUrl).href
+              : parentUrl;
+          return new URL(reference.specifier, baseUrl).href;
         },
       },
     },
@@ -131,22 +131,22 @@ export const jsenvPluginFileUrls = ({
       appliesDuring: "dev",
       resolveUrl: (reference) => {
         if (reference.specifier.startsWith("/@fs/")) {
-          const fsRootRelativeUrl = reference.specifier.slice("/@fs/".length)
-          return `file:///${fsRootRelativeUrl}`
+          const fsRootRelativeUrl = reference.specifier.slice("/@fs/".length);
+          return `file:///${fsRootRelativeUrl}`;
         }
-        return null
+        return null;
       },
       formatUrl: (reference, context) => {
         if (!reference.generatedUrl.startsWith("file:")) {
-          return null
+          return null;
         }
         if (urlIsInsideOf(reference.generatedUrl, context.rootDirectoryUrl)) {
           return `/${urlToRelativeUrl(
             reference.generatedUrl,
             context.rootDirectoryUrl,
-          )}`
+          )}`;
         }
-        return `/@fs/${reference.generatedUrl.slice("file:///".length)}`
+        return `/@fs/${reference.generatedUrl.slice("file:///".length)}`;
       },
     },
     {
@@ -154,40 +154,40 @@ export const jsenvPluginFileUrls = ({
       appliesDuring: "*",
       fetchUrlContent: (urlInfo, context) => {
         if (!urlInfo.url.startsWith("file:")) {
-          return null
+          return null;
         }
-        const urlObject = new URL(urlInfo.url)
+        const urlObject = new URL(urlInfo.url);
         if (context.reference.leadsToADirectory) {
-          const directoryEntries = readdirSync(urlObject)
-          let filename
+          const directoryEntries = readdirSync(urlObject);
+          let filename;
           if (context.reference.type === "filesystem") {
             const parentUrlInfo = context.urlGraph.getUrlInfo(
               context.reference.parentUrl,
-            )
-            filename = `${parentUrlInfo.filename}${context.reference.specifier}/`
+            );
+            filename = `${parentUrlInfo.filename}${context.reference.specifier}/`;
           } else {
-            filename = `${urlToFilename(urlInfo.url)}/`
+            filename = `${urlToFilename(urlInfo.url)}/`;
           }
           return {
             type: "directory",
             contentType: "application/json",
             content: JSON.stringify(directoryEntries, null, "  "),
             filename,
-          }
+          };
         }
-        const fileBuffer = readFileSync(urlObject)
-        const contentType = CONTENT_TYPE.fromUrlExtension(urlInfo.url)
+        const fileBuffer = readFileSync(urlObject);
+        const contentType = CONTENT_TYPE.fromUrlExtension(urlInfo.url);
         return {
           content: CONTENT_TYPE.isTextual(contentType)
             ? String(fileBuffer)
             : fileBuffer,
           contentType,
-        }
+        };
       },
     },
-  ]
-}
+  ];
+};
 
 const resolveSymlink = (fileUrl) => {
-  return pathToFileURL(realpathSync(new URL(fileUrl))).href
-}
+  return pathToFileURL(realpathSync(new URL(fileUrl))).href;
+};