@jsenv/core 39.12.0 → 39.13.1

package/src/plugins/protocol_file/jsenv_plugin_protocol_file.js

@@ -1,36 +1,18 @@
-import {
-  assertAndNormalizeDirectoryUrl,
-  comparePathnames,
-  readEntryStatSync,
-} from "@jsenv/filesystem";
-import { pickContentType } from "@jsenv/server";
-import {
-  ensurePathnameTrailingSlash,
-  urlIsInsideOf,
-  urlToFilename,
-  urlToRelativeUrl,
-} from "@jsenv/urls";
+import { readEntryStatSync } from "@jsenv/filesystem";
+import { ensurePathnameTrailingSlash } from "@jsenv/urls";
 import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
-import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
-import { lookupPackageDirectory } from "../../helpers/lookup_package_directory.js";
-import { jsenvCoreDirectoryUrl } from "../../jsenv_core_directory_url.js";
+import { readFileSync, readdirSync } from "node:fs";
+import { FILE_AND_SERVER_URLS_CONVERTER } from "./file_and_server_urls_converter.js";
+import { jsenvPluginDirectoryListing } from "./jsenv_plugin_directory_listing.js";
 import { jsenvPluginFsRedirection } from "./jsenv_plugin_fs_redirection.js";
 
-const html404AndAncestorDirFileUrl = new URL(
-  "./client/html_404_and_ancestor_dir.html",
-  import.meta.url,
-);
-const htmlFileUrlForDirectory = new URL(
-  "./client/directory.html",
-  import.meta.url,
-);
 const directoryContentMagicName = "...";
 
 export const jsenvPluginProtocolFile = ({
   magicExtensions,
   magicDirectoryIndex,
   preserveSymlinks,
-  directoryListingUrlMocks,
+  directoryListing,
 }) => {
   return [
     jsenvPluginFsRedirection({
@@ -61,8 +43,7 @@ export const jsenvPluginProtocolFile = ({
       appliesDuring: "dev",
       resolveReference: (reference) => {
         if (reference.specifier.startsWith("/@fs/")) {
-          const fsRootRelativeUrl = reference.specifier.slice("/@fs/".length);
-          return `file:///${fsRootRelativeUrl}`;
+          return FILE_AND_SERVER_URLS_CONVERTER.asFileUrl(reference.specifier);
         }
         return null;
       },
@@ -81,12 +62,43 @@ export const jsenvPluginProtocolFile = ({
           }
         }
         const { rootDirectoryUrl } = reference.ownerUrlInfo.context;
-        if (urlIsInsideOf(generatedUrl, rootDirectoryUrl)) {
-          const result = `/${urlToRelativeUrl(generatedUrl, rootDirectoryUrl)}`;
-          return result;
+        return FILE_AND_SERVER_URLS_CONVERTER.asServerUrl(
+          generatedUrl,
+          rootDirectoryUrl,
+        );
+      },
+    },
+    ...(directoryListing
+      ? [
+          jsenvPluginDirectoryListing({
+            ...directoryListing,
+            directoryContentMagicName,
+          }),
+        ]
+      : []),
+    {
+      name: "jsenv:directory_as_json",
+      appliesDuring: "*",
+      fetchUrlContent: (urlInfo) => {
+        const { firstReference } = urlInfo;
+        let { fsStat } = firstReference;
+        if (!fsStat) {
+          fsStat = readEntryStatSync(urlInfo.url, { nullIfNotFound: true });
         }
-        const result = `/@fs/${generatedUrl.slice("file:///".length)}`;
-        return result;
+        if (!fsStat) {
+          return null;
+        }
+        const isDirectory = fsStat.isDirectory();
+        if (!isDirectory) {
+          return null;
+        }
+        const directoryContentArray = readdirSync(new URL(urlInfo.url));
+        const content = JSON.stringify(directoryContentArray, null, "  ");
+        return {
+          type: "directory",
+          contentType: "application/json",
+          content,
+        };
       },
     },
     {
@@ -97,13 +109,10 @@ export const jsenvPluginProtocolFile = ({
           return null;
         }
         const { firstReference } = urlInfo;
-        const { mainFilePath } = urlInfo.context;
         let { fsStat } = firstReference;
         if (!fsStat) {
           fsStat = readEntryStatSync(urlInfo.url, { nullIfNotFound: true });
         }
-        const isDirectory = fsStat?.isDirectory();
-        const { rootDirectoryUrl, request } = urlInfo.context;
         const serveFile = (url) => {
           const contentType = CONTENT_TYPE.fromUrlExtension(url);
           const fileBuffer = readFileSync(new URL(url));
@@ -117,344 +126,8 @@ export const jsenvPluginProtocolFile = ({
           };
         };
 
-        if (!fsStat) {
-          if (request && request.headers["sec-fetch-dest"] === "document") {
-            const directoryContentItems = generateDirectoryContentItems(
-              urlInfo.url,
-              rootDirectoryUrl,
-            );
-            const html = generateHtmlForENOENT(
-              urlInfo.url,
-              directoryContentItems,
-              directoryListingUrlMocks,
-              { mainFilePath },
-            );
-            return {
-              status: 404,
-              contentType: "text/html",
-              content: html,
-              headers: {
-                "cache-control": "no-cache",
-              },
-            };
-          }
-        }
-        if (isDirectory) {
-          const directoryContentArray = readdirSync(new URL(urlInfo.url));
-          if (firstReference.type === "filesystem") {
-            const content = JSON.stringify(directoryContentArray, null, "  ");
-            return {
-              type: "directory",
-              contentType: "application/json",
-              content,
-            };
-          }
-          const acceptsHtml = request
-            ? pickContentType(request, ["text/html"])
-            : false;
-          if (acceptsHtml) {
-            firstReference.expectedType = "html";
-            const directoryUrl = urlInfo.url;
-            const directoryContentItems = generateDirectoryContentItems(
-              directoryUrl,
-              rootDirectoryUrl,
-            );
-            const html = generateHtmlForDirectory(directoryContentItems, {
-              mainFilePath,
-            });
-            return {
-              type: "html",
-              contentType: "text/html",
-              content: html,
-            };
-          }
-          return {
-            type: "directory",
-            contentType: "application/json",
-            content: JSON.stringify(directoryContentArray, null, "  "),
-          };
-        }
         return serveFile(urlInfo.url);
       },
     },
   ];
 };
-
-const generateHtmlForDirectory = (directoryContentItems, { mainFilePath }) => {
-  let directoryUrl = directoryContentItems.firstExistingDirectoryUrl;
-  const rootDirectoryUrl = directoryContentItems.rootDirectoryUrl;
-  directoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl);
-
-  const htmlForDirectory = String(readFileSync(htmlFileUrlForDirectory));
-  const replacers = {
-    directoryUrl,
-    directoryNav: () =>
-      generateDirectoryNav(directoryUrl, {
-        rootDirectoryUrl,
-        rootDirectoryUrlForServer:
-          directoryContentItems.rootDirectoryUrlForServer,
-        mainFilePath,
-      }),
-    directoryContent: () =>
-      generateDirectoryContent(directoryContentItems, { mainFilePath }),
-  };
-  const html = replacePlaceholders(htmlForDirectory, replacers);
-  return html;
-};
-const generateHtmlForENOENT = (
-  url,
-  directoryContentItems,
-  directoryListingUrlMocks,
-  { mainFilePath },
-) => {
-  const ancestorDirectoryUrl = directoryContentItems.firstExistingDirectoryUrl;
-  const rootDirectoryUrl = directoryContentItems.rootDirectoryUrl;
-
-  const htmlFor404AndAncestorDir = String(
-    readFileSync(html404AndAncestorDirFileUrl),
-  );
-  const fileRelativeUrl = urlToRelativeUrl(url, rootDirectoryUrl);
-  const ancestorDirectoryRelativeUrl = urlToRelativeUrl(
-    ancestorDirectoryUrl,
-    rootDirectoryUrl,
-  );
-  const replacers = {
-    fileUrl: directoryListingUrlMocks
-      ? `@jsenv/core/${urlToRelativeUrl(url, jsenvCoreDirectoryUrl)}`
-      : url,
-    fileRelativeUrl,
-    ancestorDirectoryUrl,
-    ancestorDirectoryRelativeUrl,
-    ancestorDirectoryNav: () =>
-      generateDirectoryNav(ancestorDirectoryUrl, {
-        rootDirectoryUrl,
-        rootDirectoryUrlForServer:
-          directoryContentItems.rootDirectoryUrlForServer,
-        mainFilePath,
-      }),
-    ancestorDirectoryContent: () =>
-      generateDirectoryContent(directoryContentItems, { mainFilePath }),
-  };
-  const html = replacePlaceholders(htmlFor404AndAncestorDir, replacers);
-  return html;
-};
-const generateDirectoryNav = (
-  entryDirectoryUrl,
-  { rootDirectoryUrl, rootDirectoryUrlForServer, mainFilePath },
-) => {
-  const entryDirectoryRelativeUrl = urlToRelativeUrl(
-    entryDirectoryUrl,
-    rootDirectoryUrl,
-  );
-  const isDir =
-    entryDirectoryRelativeUrl === "" || entryDirectoryRelativeUrl.endsWith("/");
-  const rootDirectoryUrlName = urlToFilename(rootDirectoryUrl);
-  const items = [];
-  let dirPartsHtml = "";
-  const parts = entryDirectoryRelativeUrl
-    ? `${rootDirectoryUrlName}/${entryDirectoryRelativeUrl.slice(0, -1)}`.split(
-        "/",
-      )
-    : [rootDirectoryUrlName];
-  let i = 0;
-  while (i < parts.length) {
-    const part = parts[i];
-    const directoryRelativeUrl = `${parts.slice(1, i + 1).join("/")}`;
-    const directoryUrl =
-      directoryRelativeUrl === ""
-        ? rootDirectoryUrl
-        : new URL(`${directoryRelativeUrl}/`, rootDirectoryUrl).href;
-    let href =
-      directoryUrl === rootDirectoryUrlForServer ||
-      urlIsInsideOf(directoryUrl, rootDirectoryUrlForServer)
-        ? urlToRelativeUrl(directoryUrl, rootDirectoryUrlForServer)
-        : directoryUrl;
-    if (href === "") {
-      href = `/${directoryContentMagicName}`;
-    } else {
-      href = `/${href}`;
-    }
-    const text = part;
-    items.push({
-      href,
-      text,
-    });
-    i++;
-  }
-  i = 0;
-
-  const renderDirNavItem = ({ isCurrent, href, text }) => {
-    const isServerRootDir = href === `/${directoryContentMagicName}`;
-    if (isServerRootDir) {
-      if (isCurrent) {
-        return `
-        <span class="directory_nav_item" data-current>
-          <a class="directory_root_for_server" hot-decline href="/${mainFilePath}"></a>
-          <span class="directory_name">${text}</span>
-        </span>`;
-      }
-      return `
-        <span class="directory_nav_item">
-          <a class="directory_root_for_server" hot-decline href="/${mainFilePath}"></a>
-          <a class="directory_name" hot-decline href="${href}">${text}</a>
-        </span>`;
-    }
-    if (isCurrent) {
-      return `
-      <span class="directory_nav_item" data-current>
-        <span class="directory_text">${text}</span>
-      </span>`;
-    }
-    return `
-      <span class="directory_nav_item">
-        <a class="directory_text" hot-decline href="${href}">${text}</a>
-      </span>`;
-  };
-
-  for (const { href, text } of items) {
-    const isLastPart = i === items.length - 1;
-    dirPartsHtml += renderDirNavItem({
-      isCurrent: isLastPart,
-      href,
-      text,
-    });
-    if (isLastPart) {
-      break;
-    }
-    dirPartsHtml += `
-      <span class="directory_separator">/</span>`;
-    i++;
-  }
-  if (isDir) {
-    dirPartsHtml += `
-      <span class="directory_separator">/</span>`;
-  }
-  return dirPartsHtml;
-};
-const generateDirectoryContentItems = (
-  directoryUrl,
-  rootDirectoryUrlForServer,
-) => {
-  let firstExistingDirectoryUrl = new URL("./", directoryUrl);
-  while (!existsSync(firstExistingDirectoryUrl)) {
-    firstExistingDirectoryUrl = new URL("../", firstExistingDirectoryUrl);
-    if (!urlIsInsideOf(firstExistingDirectoryUrl, rootDirectoryUrlForServer)) {
-      firstExistingDirectoryUrl = new URL(rootDirectoryUrlForServer);
-      break;
-    }
-  }
-  const directoryContentArray = readdirSync(firstExistingDirectoryUrl);
-  const fileUrls = [];
-  for (const filename of directoryContentArray) {
-    const fileUrlObject = new URL(filename, firstExistingDirectoryUrl);
-    fileUrls.push(fileUrlObject);
-  }
-  let rootDirectoryUrl = rootDirectoryUrlForServer;
-  package_workspaces: {
-    const packageDirectoryUrl = lookupPackageDirectory(
-      rootDirectoryUrlForServer,
-    );
-    if (!packageDirectoryUrl) {
-      break package_workspaces;
-    }
-    if (String(packageDirectoryUrl) === String(rootDirectoryUrlForServer)) {
-      break package_workspaces;
-    }
-    rootDirectoryUrl = packageDirectoryUrl;
-    if (
-      String(firstExistingDirectoryUrl) === String(rootDirectoryUrlForServer)
-    ) {
-      let packageContent;
-      try {
-        packageContent = JSON.parse(
-          readFileSync(new URL("package.json", packageDirectoryUrl), "utf8"),
-        );
-      } catch {
-        break package_workspaces;
-      }
-      const { workspaces } = packageContent;
-      if (Array.isArray(workspaces)) {
-        for (const workspace of workspaces) {
-          const workspaceUrlObject = new URL(workspace, packageDirectoryUrl);
-          const workspaceUrl = workspaceUrlObject.href;
-          if (workspaceUrl.endsWith("*")) {
-            const directoryUrl = ensurePathnameTrailingSlash(
-              workspaceUrl.slice(0, -1),
-            );
-            fileUrls.push(new URL(directoryUrl));
-          } else {
-            fileUrls.push(ensurePathnameTrailingSlash(workspaceUrlObject));
-          }
-        }
-      }
-    }
-  }
-
-  const sortedUrls = [];
-  for (let fileUrl of fileUrls) {
-    if (lstatSync(fileUrl).isDirectory()) {
-      sortedUrls.push(ensurePathnameTrailingSlash(fileUrl));
-    } else {
-      sortedUrls.push(fileUrl);
-    }
-  }
-  sortedUrls.sort((a, b) => {
-    return comparePathnames(a.pathname, b.pathname);
-  });
-
-  const items = [];
-  for (const sortedUrl of sortedUrls) {
-    const fileUrlRelativeToParent = urlToRelativeUrl(
-      sortedUrl,
-      firstExistingDirectoryUrl,
-    );
-    const fileUrlRelativeToServer = urlToRelativeUrl(
-      sortedUrl,
-      rootDirectoryUrlForServer,
-    );
-    const type = fileUrlRelativeToParent.endsWith("/") ? "dir" : "file";
-    items.push({
-      type,
-      fileUrlRelativeToParent,
-      fileUrlRelativeToServer,
-    });
-  }
-  items.rootDirectoryUrlForServer = rootDirectoryUrlForServer;
-  items.rootDirectoryUrl = rootDirectoryUrl;
-  items.firstExistingDirectoryUrl = firstExistingDirectoryUrl;
-  return items;
-};
-const generateDirectoryContent = (directoryContentItems, { mainFilePath }) => {
-  if (directoryContentItems.length === 0) {
-    return `<p class="directory_empty_message">Directory is empty</p>`;
-  }
-  let html = `<ul class="directory_content">`;
-  for (const directoryContentItem of directoryContentItems) {
-    const { type, fileUrlRelativeToParent, fileUrlRelativeToServer } =
-      directoryContentItem;
-    let href = fileUrlRelativeToServer;
-    if (href === "") {
-      href = `${directoryContentMagicName}`;
-    }
-    const isMainFile = href === mainFilePath;
-    const mainFileAttr = isMainFile ? ` data-main-file` : "";
-    html += `
-      <li class="directory_child" data-type="${type}"${mainFileAttr}>
-        <a href="/${href}" hot-decline>${fileUrlRelativeToParent}</a>
-      </li>`;
-  }
-  html += `\n  </ul>`;
-  return html;
-};
-const replacePlaceholders = (html, replacers) => {
-  return html.replace(/\$\{(\w+)\}/g, (match, name) => {
-    const replacer = replacers[name];
-    if (replacer === undefined) {
-      return match;
-    }
-    if (typeof replacer === "function") {
-      return replacer();
-    }
-    return replacer;
-  });
-};

package/src/plugins/protocol_http/jsenv_plugin_protocol_http.js

@@ -55,10 +55,11 @@ export const jsenvPluginProtocolHttp = ({ include }) => {
       return fileUrl;
     },
     fetchUrlContent: async (urlInfo) => {
-      if (!urlInfo.originalUrl.startsWith("http")) {
+      const originalUrl = urlInfo.originalUrl;
+      if (!originalUrl.startsWith("http")) {
         return null;
       }
-      const response = await fetch(urlInfo.originalUrl);
+      const response = await fetch(originalUrl);
       const responseStatus = response.status;
       if (responseStatus < 200 || responseStatus > 299) {
         throw new Error(`unexpected response status ${responseStatus}`);

package/src/plugins/reference_analysis/html/jsenv_plugin_html_reference_analysis.js

@@ -256,9 +256,11 @@ export const jsenvPluginHtmlReferenceAnalysis = ({
             const { line, column, isOriginal } = getHtmlNodePosition(node, {
               preferOriginal: true,
             });
-            const inlineContentUrl = getUrlForContentInsideHtml(node, {
-              htmlUrl: urlInfo.url,
-            });
+            const inlineContentUrl = getUrlForContentInsideHtml(
+              node,
+              urlInfo,
+              null,
+            );
             const debug =
               getHtmlNodeAttribute(node, "jsenv-debug") !== undefined;
             const inlineReference = urlInfo.dependencies.foundInline({
@@ -399,9 +401,8 @@ export const jsenvPluginHtmlReferenceAnalysis = ({
                   );
                   const importmapInlineUrl = getUrlForContentInsideHtml(
                     scriptNode,
-                    {
-                      htmlUrl: urlInfo.url,
-                    },
+                    urlInfo,
+                    importmapReference,
                   );
                   const importmapReferenceInlined = importmapReference.inline({
                     line,

package/src/plugins/reference_analysis/js/jsenv_plugin_js_reference_analysis.js

@@ -41,9 +41,7 @@ const parseAndTransformJsReferences = async (
     Object.keys(urlInfo.context.runtimeCompat).toString() === "node";
 
   const onInlineReference = (inlineReferenceInfo) => {
-    const inlineUrl = getUrlForContentInsideJs(inlineReferenceInfo, {
-      url: urlInfo.url,
-    });
+    const inlineUrl = getUrlForContentInsideJs(inlineReferenceInfo, urlInfo);
     let { quote } = inlineReferenceInfo;
     if (quote === "`" && !canUseTemplateLiterals) {
       // if quote is "`" and template literals are not supported

package/src/plugins/reference_analysis/jsenv_plugin_reference_analysis.js

@@ -41,23 +41,7 @@ const jsenvPluginInlineContentFetcher = () => {
       if (!urlInfo.isInline) {
         return null;
       }
-      let isDirectRequestToFile;
-      if (urlInfo.context.request) {
-        let requestResource = urlInfo.context.request.resource;
-        let requestedUrl;
-        if (requestResource.startsWith("/@fs/")) {
-          const fsRootRelativeUrl = requestResource.slice("/@fs/".length);
-          requestedUrl = `file:///${fsRootRelativeUrl}`;
-        } else {
-          const requestedUrlObject = new URL(
-            requestResource.slice(1),
-            urlInfo.context.rootDirectoryUrl,
-          );
-          requestedUrlObject.searchParams.delete("hot");
-          requestedUrl = requestedUrlObject.href;
-        }
-        isDirectRequestToFile = requestedUrl === urlInfo.url;
-      }
+      const isDirectRequest = urlInfo.context.requestedUrl === urlInfo.url;
       /*
        * We want to find inline content but it's not straightforward
        *
@@ -86,7 +70,7 @@ const jsenvPluginInlineContentFetcher = () => {
           originalContent = reference.content;
         }
         lastInlineReference = reference;
-        if (isDirectRequestToFile) {
+        if (isDirectRequest) {
           break;
         }
       }

package/src/plugins/server_events/jsenv_plugin_server_events.js

@@ -0,0 +1,100 @@
+/*
+ * This plugin is very special because it is here
+ * to provide "serverEvents" used by other plugins
+ */
+
+import { injectJsenvScript, parseHtml, stringifyHtmlAst } from "@jsenv/ast";
+import { createServerEventsDispatcher } from "./server_events_dispatcher.js";
+
+const serverEventsClientFileUrl = new URL(
+  "./client/server_events_client.js",
+  import.meta.url,
+).href;
+
+export const jsenvPluginServerEvents = ({ clientAutoreload }) => {
+  let serverEventsDispatcher;
+
+  const { clientServerEventsConfig } = clientAutoreload;
+  const { logs = true } = clientServerEventsConfig;
+
+  return {
+    name: "jsenv:server_events",
+    appliesDuring: "dev",
+    effect: ({ kitchenContext, otherPlugins }) => {
+      const allServerEvents = {};
+      for (const otherPlugin of otherPlugins) {
+        const { serverEvents } = otherPlugin;
+        if (!serverEvents) {
+          continue;
+        }
+        for (const serverEventName of Object.keys(serverEvents)) {
+          // we could throw on serverEvent name conflict
+          // we could throw if serverEvents[serverEventName] is not a function
+          allServerEvents[serverEventName] = serverEvents[serverEventName];
+        }
+      }
+      const serverEventNames = Object.keys(allServerEvents);
+      if (serverEventNames.length === 0) {
+        return false;
+      }
+      serverEventsDispatcher = createServerEventsDispatcher();
+      const onabort = () => {
+        serverEventsDispatcher.destroy();
+      };
+      kitchenContext.signal.addEventListener("abort", onabort);
+      for (const serverEventName of Object.keys(allServerEvents)) {
+        const serverEventInfo = {
+          ...kitchenContext,
+          // serverEventsDispatcher variable is safe, we can disable esling warning
+          // eslint-disable-next-line no-loop-func
+          sendServerEvent: (data) => {
+            if (!serverEventsDispatcher) {
+              // this can happen if a plugin wants to send a server event but
+              // server is closing or the plugin got destroyed but still wants to do things
+              // if plugin code is correctly written it is never supposed to happen
+              // because it means a plugin is still trying to do stuff after being destroyed
+              return;
+            }
+            serverEventsDispatcher.dispatch({
+              type: serverEventName,
+              data,
+            });
+          },
+        };
+        const serverEventInit = allServerEvents[serverEventName];
+        serverEventInit(serverEventInfo);
+      }
+      return () => {
+        kitchenContext.signal.removeEventListener("abort", onabort);
+        serverEventsDispatcher.destroy();
+        serverEventsDispatcher = undefined;
+      };
+    },
+    serveWebsocket: async ({ websocket, request }) => {
+      if (request.headers["sec-websocket-protocol"] !== "jsenv") {
+        return false;
+      }
+      serverEventsDispatcher.addWebsocket(websocket, request);
+      return true;
+    },
+    transformUrlContent: {
+      html: (urlInfo) => {
+        const htmlAst = parseHtml({
+          html: urlInfo.content,
+          url: urlInfo.url,
+        });
+        injectJsenvScript(htmlAst, {
+          src: serverEventsClientFileUrl,
+          initCall: {
+            callee: "window.__server_events__.setup",
+            params: {
+              logs,
+            },
+          },
+          pluginName: "jsenv:server_events",
+        });
+        return stringifyHtmlAst(htmlAst);
+      },
+    },
+  };
+};