@jsenv/core 38.4.16 → 38.4.18

package/src/plugins/protocol_file/jsenv_plugin_protocol_file.js

@@ -1,5 +1,11 @@
-import { readFileSync, realpathSync, statSync } from "node:fs";
-import { serveDirectory } from "@jsenv/server";
+import {
+  existsSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+  lstatSync,
+  readdirSync,
+} from "node:fs";
 import { pathToFileURL } from "node:url";
 import {
   urlIsInsideOf,
@@ -11,7 +17,19 @@ import {
   applyFileSystemMagicResolution,
   getExtensionsToTry,
 } from "@jsenv/node-esm-resolution";
+import { pickContentType } from "@jsenv/server";
 import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
+
+const html404AndParentDirIsEmptyFileUrl = new URL(
+  "./html_404_and_parent_dir_is_empty.html",
+  import.meta.url,
+);
+const html404AndParentDirFileUrl = new URL(
+  "./html_404_and_parent_dir.html",
+  import.meta.url,
+);
+const htmlFileUrlForDirectory = new URL("./directory.html", import.meta.url);
 
 export const jsenvPluginProtocolFile = ({
   magicExtensions = ["inherit", ".js"],
@@ -99,7 +117,9 @@ export const jsenvPluginProtocolFile = ({
         reference.leadsToADirectory = stat && stat.isDirectory();
         if (reference.leadsToADirectory) {
           let actionForDirectory;
-          if (
+          if (reference.type === "a_href") {
+            actionForDirectory = "ignore";
+          } else if (
             reference.type === "http_request" ||
             reference.type === "filesystem"
           ) {
@@ -184,17 +204,33 @@ export const jsenvPluginProtocolFile = ({
               urlInfo.filenameHint = `${urlToFilename(urlInfo.url)}/`;
             }
           }
-          const { headers, body } = serveDirectory(urlObject.href, {
-            headers: urlInfo.context.request
-              ? urlInfo.context.request.headers
-              : {},
-            rootDirectoryUrl: urlInfo.context.rootDirectoryUrl,
-          });
+          const directoryContentArray = readdirSync(urlObject);
+          if (urlInfo.firstReference.type === "filesystem") {
+            const content = JSON.stringify(directoryContentArray, null, "  ");
+            return {
+              type: "directory",
+              contentType: "application/json",
+              content,
+            };
+          }
+          const acceptsHtml = urlInfo.context.request
+            ? pickContentType(urlInfo.context.request, ["text/html"])
+            : false;
+          if (acceptsHtml) {
+            const html = generateHtmlForDirectory(
+              urlObject.href,
+              directoryContentArray,
+              urlInfo.context.rootDirectoryUrl,
+            );
+            return {
+              contentType: "text/html",
+              content: html,
+            };
+          }
           return {
             type: "directory",
-            contentType: headers["content-type"],
-            contentLength: headers["content-length"],
-            content: body,
+            contentType: "application/json",
+            content: JSON.stringify(directoryContentArray, null, "  "),
           };
         }
         if (
@@ -204,20 +240,144 @@ export const jsenvPluginProtocolFile = ({
           urlInfo.dirnameHint =
             urlInfo.firstReference.ownerUrlInfo.filenameHint;
         }
-        const fileBuffer = readFileSync(urlObject);
         const contentType = CONTENT_TYPE.fromUrlExtension(urlInfo.url);
+        if (contentType === "text/html") {
+          try {
+            const fileBuffer = readFileSync(urlObject);
+            const content = String(fileBuffer);
+            return {
+              content,
+              contentType,
+              contentLength: fileBuffer.length,
+            };
+          } catch (e) {
+            if (e.code !== "ENOENT") {
+              throw e;
+            }
+            const parentDirectoryUrl = new URL("./", urlInfo.url);
+            if (!existsSync(parentDirectoryUrl)) {
+              throw e;
+            }
+            const parentDirectoryContentArray = readdirSync(
+              new URL(parentDirectoryUrl),
+            );
+            const html = generateHtmlForENOENTOnHtmlFile(
+              urlInfo.url,
+              parentDirectoryContentArray,
+              parentDirectoryUrl,
+              urlInfo.context.rootDirectoryUrl,
+            );
+            return {
+              contentType: "text/html",
+              content: html,
+            };
+          }
+        }
+        const fileBuffer = readFileSync(urlObject);
         const content = CONTENT_TYPE.isTextual(contentType)
           ? String(fileBuffer)
           : fileBuffer;
         return {
           content,
           contentType,
+          contentLength: fileBuffer.length,
         };
       },
     },
   ];
 };
 
+const generateHtmlForDirectory = (
+  directoryUrl,
+  directoryContentArray,
+  rootDirectoryUrl,
+) => {
+  directoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl);
+  const htmlForDirectory = String(readFileSync(htmlFileUrlForDirectory));
+  const replacers = {
+    directoryRelativeUrl: urlToRelativeUrl(directoryUrl, rootDirectoryUrl),
+    directoryUrl,
+    directoryContent: () =>
+      generateDirectoryContent(
+        directoryContentArray,
+        directoryUrl,
+        rootDirectoryUrl,
+      ),
+  };
+  const html = replacePlaceholders(htmlForDirectory, replacers);
+  return html;
+};
+const generateHtmlForENOENTOnHtmlFile = (
+  url,
+  parentDirectoryContentArray,
+  parentDirectoryUrl,
+  rootDirectoryUrl,
+) => {
+  if (parentDirectoryContentArray.length === 0) {
+    const htmlFor404AndParentDirIsEmpty = String(
+      readFileSync(html404AndParentDirIsEmptyFileUrl),
+    );
+    return replacePlaceholders(htmlFor404AndParentDirIsEmpty, {
+      fileRelativeUrl: urlToRelativeUrl(url, rootDirectoryUrl),
+      parentDirectoryRelativeUrl: urlToRelativeUrl(
+        parentDirectoryUrl,
+        rootDirectoryUrl,
+      ),
+    });
+  }
+  const htmlFor404AndParentDir = String(
+    readFileSync(html404AndParentDirFileUrl),
+  );
+
+  const replacers = {
+    fileUrl: url,
+    fileRelativeUrl: urlToRelativeUrl(url, rootDirectoryUrl),
+    parentDirectoryUrl,
+    parentDirectoryRelativeUrl: urlToRelativeUrl(
+      parentDirectoryUrl,
+      rootDirectoryUrl,
+    ),
+    parentDirectoryContent: () =>
+      generateDirectoryContent(
+        parentDirectoryContentArray,
+        parentDirectoryUrl,
+        rootDirectoryUrl,
+      ),
+  };
+  const html = replacePlaceholders(htmlFor404AndParentDir, replacers);
+  return html;
+};
+const generateDirectoryContent = (
+  directoryContentArray,
+  directoryUrl,
+  rootDirectoryUrl,
+) => {
+  return directoryContentArray.map((filename) => {
+    const fileUrlObject = new URL(filename, directoryUrl);
+    const fileUrl = String(fileUrlObject);
+    let fileUrlRelative = urlToRelativeUrl(fileUrl, rootDirectoryUrl);
+    if (lstatSync(fileUrlObject).isDirectory()) {
+      fileUrlRelative += "/";
+    }
+    return `<li>
+    <a href="/${fileUrlRelative}">/${fileUrlRelative}</a>
+  </li>`;
+  }).join(`
+  `);
+};
+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;
+  });
+};
+
 const resolveSymlink = (fileUrl) => {
   const urlObject = new URL(fileUrl);
   const realpath = realpathSync(urlObject);

package/src/plugins/reference_analysis/html/html_syntax_error.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Syntax error in HTML</title>
+    <meta charset="utf-8" />
+    <link rel="icon" href="data:," />
+  </head>
+
+  <body>
+    <p>Syntax error: <strong>${reasonCode}</strong></p>
+    <a jsenv-ignore href="${errorLinkHref}">${errorLinkText}</a>
+    <pre>${syntaxError}</pre>
+  </body>
+</html>