@jsenv/core 39.7.6 → 39.8.0

package/dist/jsenv_core.js

@@ -3,7 +3,7 @@ import os, { networkInterfaces } from "node:os";
 import tty from "node:tty";
 import stringWidth from "string-width";
 import { pathToFileURL, fileURLToPath } from "node:url";
-import { readdir, chmod, stat, lstat, chmodSync, statSync, lstatSync, promises, readFileSync, writeFileSync as writeFileSync$1, mkdirSync, unlink, openSync, closeSync, rmdir, watch, readdirSync, createReadStream, readFile, existsSync, realpathSync } from "node:fs";
+import { readdir, chmod, stat, lstat, chmodSync, statSync, lstatSync, promises, unlinkSync, openSync, closeSync, readdirSync, rmdirSync, mkdirSync, readFileSync, writeFileSync as writeFileSync$1, unlink, rmdir, watch, createReadStream, readFile, existsSync, realpathSync } from "node:fs";
 import { extname } from "node:path";
 import crypto, { createHash } from "node:crypto";
 import cluster from "node:cluster";
@@ -2058,6 +2058,42 @@ const extractDriveLetter = (resource) => {
   return null;
 };
 
+const getParentDirectoryUrl = (url) => {
+  if (url.startsWith("file://")) {
+    // With node.js new URL('../', 'file:///C:/').href
+    // returns "file:///C:/" instead of "file:///"
+    const resource = url.slice("file://".length);
+    const slashLastIndex = resource.lastIndexOf("/");
+    if (slashLastIndex === -1) {
+      return url;
+    }
+    const lastCharIndex = resource.length - 1;
+    if (slashLastIndex === lastCharIndex) {
+      const slashBeforeLastIndex = resource.lastIndexOf(
+        "/",
+        slashLastIndex - 1,
+      );
+      if (slashBeforeLastIndex === -1) {
+        return url;
+      }
+      return `file://${resource.slice(0, slashBeforeLastIndex + 1)}`;
+    }
+    return `file://${resource.slice(0, slashLastIndex + 1)}`;
+  }
+  return new URL(url.endsWith("/") ? "../" : "./", url).href;
+};
+
+const findAncestorDirectoryUrl = (url, callback) => {
+  url = String(url);
+  while (url !== "file:///") {
+    if (callback(url)) {
+      return url;
+    }
+    url = getParentDirectoryUrl(url);
+  }
+  return null;
+};
+
 const createCallbackListNotifiedOnce = () => {
   let callbacks = [];
   let status = "waiting";
@@ -3610,7 +3646,284 @@ const normalizeMediaType = (value) => {
   return value;
 };
 
-const writeFileSync = (destination, content = "") => {
+const removeEntrySync = (
+  source,
+  {
+    allowUseless = false,
+    recursive = false,
+    maxRetries = 3,
+    retryDelay = 100,
+    onlyContent = false,
+  } = {},
+) => {
+  const sourceUrl = assertAndNormalizeFileUrl(source);
+  const sourceStats = readEntryStatSync(sourceUrl, {
+    nullIfNotFound: true,
+    followLink: false,
+  });
+  if (!sourceStats) {
+    if (allowUseless) {
+      return;
+    }
+    throw new Error(`nothing to remove at ${urlToFileSystemPath(sourceUrl)}`);
+  }
+
+  // https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_class_fs_stats
+  // FIFO and socket are ignored, not sure what they are exactly and what to do with them
+  // other libraries ignore them, let's do the same.
+  if (
+    sourceStats.isFile() ||
+    sourceStats.isSymbolicLink() ||
+    sourceStats.isCharacterDevice() ||
+    sourceStats.isBlockDevice()
+  ) {
+    removeNonDirectory$1(
+      sourceUrl.endsWith("/") ? sourceUrl.slice(0, -1) : sourceUrl);
+  } else if (sourceStats.isDirectory()) {
+    const directoryUrl = ensurePathnameTrailingSlash(sourceUrl);
+    removeDirectorySync$1(directoryUrl, {
+      recursive,
+      maxRetries,
+      retryDelay,
+      onlyContent,
+    });
+  }
+};
+
+const removeNonDirectory$1 = (sourceUrl) => {
+  const sourcePath = urlToFileSystemPath(sourceUrl);
+  const attempt = () => {
+    unlinkSyncNaive(sourcePath);
+  };
+  attempt();
+};
+
+const unlinkSyncNaive = (sourcePath, { handleTemporaryError = null } = {}) => {
+  try {
+    unlinkSync(sourcePath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    if (
+      handleTemporaryError &&
+      (error.code === "EBUSY" ||
+        error.code === "EMFILE" ||
+        error.code === "ENFILE" ||
+        error.code === "ENOENT")
+    ) {
+      handleTemporaryError(error);
+      return;
+    }
+    throw error;
+  }
+};
+
+const removeDirectorySync$1 = (
+  rootDirectoryUrl,
+  { maxRetries, retryDelay, recursive, onlyContent },
+) => {
+  const visit = (sourceUrl) => {
+    const sourceStats = readEntryStatSync(sourceUrl, {
+      nullIfNotFound: true,
+      followLink: false,
+    });
+
+    // file/directory not found
+    if (sourceStats === null) {
+      return;
+    }
+
+    if (
+      sourceStats.isFile() ||
+      sourceStats.isCharacterDevice() ||
+      sourceStats.isBlockDevice()
+    ) {
+      visitFile(sourceUrl);
+    } else if (sourceStats.isSymbolicLink()) {
+      visitSymbolicLink(sourceUrl);
+    } else if (sourceStats.isDirectory()) {
+      visitDirectory(`${sourceUrl}/`);
+    }
+  };
+
+  const visitDirectory = (directoryUrl) => {
+    const directoryPath = urlToFileSystemPath(directoryUrl);
+    const optionsFromRecursive = recursive
+      ? {
+          handleNotEmptyError: () => {
+            removeDirectoryContent(directoryUrl);
+            visitDirectory(directoryUrl);
+          },
+        }
+      : {};
+    removeDirectorySyncNaive(directoryPath, {
+      ...optionsFromRecursive,
+      // Workaround for https://github.com/joyent/node/issues/4337
+      ...(process.platform === "win32"
+        ? {
+            handlePermissionError: (error) => {
+              console.error(
+                `trying to fix windows EPERM after readir on ${directoryPath}`,
+              );
+
+              let openOrCloseError;
+              try {
+                const fd = openSync(directoryPath);
+                closeSync(fd);
+              } catch (e) {
+                openOrCloseError = e;
+              }
+
+              if (openOrCloseError) {
+                if (openOrCloseError.code === "ENOENT") {
+                  return;
+                }
+                console.error(
+                  `error while trying to fix windows EPERM after readir on ${directoryPath}: ${openOrCloseError.stack}`,
+                );
+                throw error;
+              }
+              removeDirectorySyncNaive(directoryPath, {
+                ...optionsFromRecursive,
+              });
+            },
+          }
+        : {}),
+    });
+  };
+
+  const removeDirectoryContent = (directoryUrl) => {
+    const entryNames = readdirSync(new URL(directoryUrl));
+    for (const entryName of entryNames) {
+      const url = resolveUrl$1(entryName, directoryUrl);
+      visit(url);
+    }
+  };
+
+  const visitFile = (fileUrl) => {
+    removeNonDirectory$1(fileUrl);
+  };
+
+  const visitSymbolicLink = (symbolicLinkUrl) => {
+    removeNonDirectory$1(symbolicLinkUrl);
+  };
+
+  if (onlyContent) {
+    removeDirectoryContent(rootDirectoryUrl);
+  } else {
+    visitDirectory(rootDirectoryUrl);
+  }
+};
+
+const removeDirectorySyncNaive = (
+  directoryPath,
+  { handleNotEmptyError = null, handlePermissionError = null } = {},
+) => {
+  try {
+    rmdirSync(directoryPath);
+  } catch (error) {
+    if (handlePermissionError && error.code === "EPERM") {
+      handlePermissionError(error);
+      return;
+    }
+    if (error.code === "ENOENT") {
+      return;
+    }
+    if (
+      handleNotEmptyError &&
+      // linux os
+      (error.code === "ENOTEMPTY" ||
+        // SunOS
+        error.code === "EEXIST")
+    ) {
+      handleNotEmptyError(error);
+      return;
+    }
+    throw error;
+  }
+};
+
+const removeDirectorySync = (url, options = {}) => {
+  return removeEntrySync(url, {
+    ...options,
+    recursive: true,
+  });
+};
+
+const writeDirectorySync = (
+  destination,
+  { recursive = true, allowUseless = false, force } = {},
+) => {
+  const destinationUrl = assertAndNormalizeDirectoryUrl(destination);
+  const destinationPath = urlToFileSystemPath(destinationUrl);
+
+  let destinationStats;
+  try {
+    destinationStats = readEntryStatSync(destinationUrl, {
+      nullIfNotFound: true,
+      followLink: false,
+    });
+  } catch (e) {
+    if (e.code === "ENOTDIR") {
+      let previousNonDirUrl = destinationUrl;
+      // we must try all parent directories as long as it fails with ENOTDIR
+      findAncestorDirectoryUrl(destinationUrl, (ancestorUrl) => {
+        try {
+          statSync(new URL(ancestorUrl));
+          return true;
+        } catch (e) {
+          if (e.code === "ENOTDIR") {
+            previousNonDirUrl = ancestorUrl;
+            return false;
+          }
+          throw e;
+        }
+      });
+      if (force) {
+        unlinkSync(
+          new URL(
+            previousNonDirUrl
+              // remove trailing slash
+              .slice(0, -1),
+          ),
+        );
+      } else {
+        throw new Error(
+          `cannot write directory at ${destinationPath} because there is a file at ${urlToFileSystemPath(
+            previousNonDirUrl,
+          )}`,
+        );
+      }
+    } else {
+      throw e;
+    }
+  }
+
+  if (destinationStats) {
+    if (destinationStats.isDirectory()) {
+      if (allowUseless) {
+        return;
+      }
+      throw new Error(`directory already exists at ${destinationPath}`);
+    }
+    const destinationType = statsToType(destinationStats);
+    throw new Error(
+      `cannot write directory at ${destinationPath} because there is a ${destinationType}`,
+    );
+  }
+
+  try {
+    mkdirSync(destinationPath, { recursive });
+  } catch (error) {
+    if (allowUseless && error.code === "EEXIST") {
+      return;
+    }
+    throw error;
+  }
+};
+
+const writeFileSync = (destination, content = "", { force } = {}) => {
   const destinationUrl = assertAndNormalizeFileUrl(destination);
   const destinationUrlObject = new URL(destinationUrl);
   if (content && content instanceof URL) {
@@ -3619,8 +3932,18 @@ const writeFileSync = (destination, content = "") => {
   try {
     writeFileSync$1(destinationUrlObject, content);
   } catch (error) {
-    if (error.code === "ENOENT") {
-      mkdirSync(new URL("./", destinationUrlObject), {
+    if (error.code === "EISDIR") {
+      // happens when directory existed but got deleted and now it's a file
+      if (force) {
+        removeDirectorySync(destinationUrlObject);
+        writeFileSync$1(destinationUrlObject, content);
+      } else {
+        throw error;
+      }
+    }
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+      writeDirectorySync(new URL("./", destinationUrlObject), {
+        force,
         recursive: true,
       });
       writeFileSync$1(destinationUrlObject, content);
@@ -11159,39 +11482,10 @@ const jsenvPluginTranspilation = ({
 };
 
 const lookupPackageDirectory = (currentUrl) => {
-  if (currentUrl === "file:///") {
-    return null;
-  }
-  const packageJsonFileUrl = `${currentUrl}package.json`;
-  if (existsSync(new URL(packageJsonFileUrl))) {
-    return currentUrl;
-  }
-  return lookupPackageDirectory(getParentUrl$1(currentUrl));
-};
-
-const getParentUrl$1 = (url) => {
-  if (url.startsWith("file://")) {
-    // With node.js new URL('../', 'file:///C:/').href
-    // returns "file:///C:/" instead of "file:///"
-    const resource = url.slice("file://".length);
-    const slashLastIndex = resource.lastIndexOf("/");
-    if (slashLastIndex === -1) {
-      return url;
-    }
-    const lastCharIndex = resource.length - 1;
-    if (slashLastIndex === lastCharIndex) {
-      const slashBeforeLastIndex = resource.lastIndexOf(
-        "/",
-        slashLastIndex - 1,
-      );
-      if (slashBeforeLastIndex === -1) {
-        return url;
-      }
-      return `file://${resource.slice(0, slashBeforeLastIndex + 1)}`;
-    }
-    return `file://${resource.slice(0, slashLastIndex + 1)}`;
-  }
-  return new URL(url.endsWith("/") ? "../" : "./", url).href;
+  return findAncestorDirectoryUrl(currentUrl, (ancestorDirectoryUrl) => {
+    const potentialPackageJsonFileUrl = `${ancestorDirectoryUrl}package.json`;
+    return existsSync(new URL(potentialPackageJsonFileUrl));
+  });
 };
 
 const watchSourceFiles = (
@@ -14163,7 +14457,7 @@ const createUrlInfoTransformer = ({
       contentIsInlined = false;
     }
     if (!contentIsInlined) {
-      writeFileSync(new URL(generatedUrl), urlInfo.content);
+      writeFileSync(new URL(generatedUrl), urlInfo.content, { force: true });
     }
     const { sourcemapGeneratedUrl, sourcemapReference } = urlInfo;
     if (sourcemapGeneratedUrl && sourcemapReference) {
@@ -18959,6 +19253,7 @@ const jsenvPluginProtocolFile = ({
         if (!urlInfo.url.startsWith("file:")) {
           return null;
         }
+        const { rootDirectoryUrl } = urlInfo.context;
         const generateContent = () => {
           const urlObject = new URL(urlInfo.url);
           const { firstReference } = urlInfo;
@@ -18977,11 +19272,12 @@ const jsenvPluginProtocolFile = ({
               : false;
             if (acceptsHtml) {
               firstReference.expectedType = "html";
-              const html = generateHtmlForDirectory(
-                urlObject.href,
-                directoryContentArray,
-                urlInfo.context.rootDirectoryUrl,
+              const directoryUrl = urlObject.href;
+              const directoryContentItems = generateDirectoryContentItems(
+                directoryUrl,
+                rootDirectoryUrl,
               );
+              const html = generateHtmlForDirectory(directoryContentItems);
               return {
                 type: "html",
                 contentType: "text/html",
@@ -19014,32 +19310,13 @@ const jsenvPluginProtocolFile = ({
             if (e.code !== "ENOENT") {
               throw e;
             }
-            const rootDirectoryUrl = urlInfo.context.rootDirectoryUrl;
-            let firstExistingAncestorDirectoryUrl = new URL("./", urlInfo.url);
-            while (!existsSync(firstExistingAncestorDirectoryUrl)) {
-              firstExistingAncestorDirectoryUrl = new URL(
-                "../",
-                firstExistingAncestorDirectoryUrl,
-              );
-              if (
-                !urlIsInsideOf(
-                  firstExistingAncestorDirectoryUrl,
-                  rootDirectoryUrl,
-                )
-              ) {
-                firstExistingAncestorDirectoryUrl = rootDirectoryUrl;
-                break;
-              }
-            }
-
-            const firstExistingAncestorDirectoryContent = readdirSync(
-              new URL(firstExistingAncestorDirectoryUrl),
+            const directoryContentItems = generateDirectoryContentItems(
+              urlInfo.url,
+              rootDirectoryUrl,
             );
             const html = generateHtmlForENOENT(
               urlInfo.url,
-              firstExistingAncestorDirectoryContent,
-              firstExistingAncestorDirectoryUrl,
-              urlInfo.context.rootDirectoryUrl,
+              directoryContentItems,
               directoryListingUrlMocks,
             );
             return {
@@ -19058,11 +19335,9 @@ const jsenvPluginProtocolFile = ({
   ];
 };
 
-const generateHtmlForDirectory = (
-  directoryUrl,
-  directoryContentArray,
-  rootDirectoryUrl,
-) => {
+const generateHtmlForDirectory = (directoryContentItems) => {
+  let directoryUrl = directoryContentItems.firstExistingDirectoryUrl;
+  const rootDirectoryUrl = directoryContentItems.rootDirectoryUrl;
   directoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl);
 
   const htmlForDirectory = String(readFileSync(htmlFileUrlForDirectory));
@@ -19071,23 +19346,19 @@ const generateHtmlForDirectory = (
     directoryUrl,
     directoryNav: () =>
       generateDirectoryNav(directoryRelativeUrl, rootDirectoryUrl),
-    directoryContent: () =>
-      generateDirectoryContent(
-        directoryContentArray,
-        directoryUrl,
-        rootDirectoryUrl,
-      ),
+    directoryContent: () => generateDirectoryContent(directoryContentItems),
   };
   const html = replacePlaceholders$1(htmlForDirectory, replacers);
   return html;
 };
 const generateHtmlForENOENT = (
   url,
-  ancestorDirectoryContentArray,
-  ancestorDirectoryUrl,
-  rootDirectoryUrl,
+  directoryContentItems,
   directoryListingUrlMocks,
 ) => {
+  const ancestorDirectoryUrl = directoryContentItems.firstExistingDirectoryUrl;
+  const rootDirectoryUrl = directoryContentItems.rootDirectoryUrl;
+
   const htmlFor404AndAncestorDir = String(
     readFileSync(html404AndAncestorDirFileUrl),
   );
@@ -19106,11 +19377,7 @@ const generateHtmlForENOENT = (
     ancestorDirectoryNav: () =>
       generateDirectoryNav(ancestorDirectoryRelativeUrl, rootDirectoryUrl),
     ancestorDirectoryContent: () =>
-      generateDirectoryContent(
-        ancestorDirectoryContentArray,
-        ancestorDirectoryUrl,
-        rootDirectoryUrl,
-      ),
+      generateDirectoryContent(directoryContentItems),
   };
   const html = replacePlaceholders$1(htmlFor404AndAncestorDir, replacers);
   return html;
@@ -19152,31 +19419,95 @@ const generateDirectoryNav = (relativeUrl, rootDirectoryUrl) => {
   }
   return dirPartsHtml;
 };
-const generateDirectoryContent = (
-  directoryContentArray,
-  directoryUrl,
-  rootDirectoryUrl,
-) => {
-  if (directoryContentArray.length === 0) {
-    return `<p>Directory is empty</p>`;
+const generateDirectoryContentItems = (directoryUrl, rootDirectoryUrl) => {
+  let firstExistingDirectoryUrl = new URL("./", directoryUrl);
+  while (!existsSync(firstExistingDirectoryUrl)) {
+    firstExistingDirectoryUrl = new URL("../", firstExistingDirectoryUrl);
+    if (!urlIsInsideOf(firstExistingDirectoryUrl, rootDirectoryUrl)) {
+      firstExistingDirectoryUrl = new URL(rootDirectoryUrl);
+      break;
+    }
   }
-  const sortedNames = [];
+  const directoryContentArray = readdirSync(firstExistingDirectoryUrl);
+  const fileUrls = [];
   for (const filename of directoryContentArray) {
-    const fileUrlObject = new URL(filename, directoryUrl);
-    if (lstatSync(fileUrlObject).isDirectory()) {
-      sortedNames.push(`${filename}/`);
+    const fileUrlObject = new URL(filename, firstExistingDirectoryUrl);
+    fileUrls.push(fileUrlObject);
+  }
+  package_workspaces: {
+    if (String(firstExistingDirectoryUrl) !== String(rootDirectoryUrl)) {
+      break package_workspaces;
+    }
+    const packageDirectoryUrl = lookupPackageDirectory(rootDirectoryUrl);
+    if (!packageDirectoryUrl) {
+      break package_workspaces;
+    }
+    if (String(packageDirectoryUrl) === String(rootDirectoryUrl)) {
+      break package_workspaces;
+    }
+    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 {
-      sortedNames.push(filename);
+      sortedUrls.push(fileUrl);
     }
   }
-  sortedNames.sort(comparePathnames);
-  let html = `<ul class="directory_content">`;
-  for (const filename of sortedNames) {
-    const fileUrlObject = new URL(filename, directoryUrl);
-    const fileUrl = String(fileUrlObject);
-    const fileUrlRelativeToParent = urlToRelativeUrl(fileUrl, directoryUrl);
-    const fileUrlRelativeToRoot = urlToRelativeUrl(fileUrl, rootDirectoryUrl);
+  sortedUrls.sort((a, b) => {
+    return comparePathnames(a.pathname, b.pathname);
+  });
+
+  const items = [];
+  for (const sortedUrl of sortedUrls) {
+    const fileUrlRelativeToParent = urlToRelativeUrl(
+      sortedUrl,
+      firstExistingDirectoryUrl,
+    );
+    const fileUrlRelativeToRoot = urlToRelativeUrl(sortedUrl, rootDirectoryUrl);
     const type = fileUrlRelativeToParent.endsWith("/") ? "dir" : "file";
+    items.push({
+      type,
+      fileUrlRelativeToParent,
+      fileUrlRelativeToRoot,
+    });
+  }
+  items.rootDirectoryUrl = rootDirectoryUrl;
+  items.firstExistingDirectoryUrl = firstExistingDirectoryUrl;
+  return items;
+};
+const generateDirectoryContent = (directoryContentItems) => {
+  if (directoryContentItems.length === 0) {
+    return `<p>Directory is empty</p>`;
+  }
+  let html = `<ul class="directory_content">`;
+  for (const directoryContentItem of directoryContentItems) {
+    const { type, fileUrlRelativeToParent, fileUrlRelativeToRoot } =
+      directoryContentItem;
     html += `
       <li class="directory_child" data-type="${type}">
         <a href="/${fileUrlRelativeToRoot}">${fileUrlRelativeToParent}</a>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "39.7.6",
+  "version": "39.8.0",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "author": {
@@ -70,7 +70,7 @@
     "@financial-times/polyfill-useragent-normaliser": "1.10.2",
     "@jsenv/abort": "4.3.0",
     "@jsenv/ast": "6.4.1",
-    "@jsenv/filesystem": "4.11.0",
+    "@jsenv/filesystem": "4.12.0",
     "@jsenv/humanize": "1.2.8",
     "@jsenv/importmap": "1.2.1",
     "@jsenv/integrity": "0.0.2",

package/src/helpers/lookup_package_directory.js

@@ -1,37 +1,9 @@
+import { findAncestorDirectoryUrl } from "@jsenv/filesystem";
 import { existsSync } from "node:fs";
 
 export const lookupPackageDirectory = (currentUrl) => {
-  if (currentUrl === "file:///") {
-    return null;
-  }
-  const packageJsonFileUrl = `${currentUrl}package.json`;
-  if (existsSync(new URL(packageJsonFileUrl))) {
-    return currentUrl;
-  }
-  return lookupPackageDirectory(getParentUrl(currentUrl));
-};
-
-const getParentUrl = (url) => {
-  if (url.startsWith("file://")) {
-    // With node.js new URL('../', 'file:///C:/').href
-    // returns "file:///C:/" instead of "file:///"
-    const resource = url.slice("file://".length);
-    const slashLastIndex = resource.lastIndexOf("/");
-    if (slashLastIndex === -1) {
-      return url;
-    }
-    const lastCharIndex = resource.length - 1;
-    if (slashLastIndex === lastCharIndex) {
-      const slashBeforeLastIndex = resource.lastIndexOf(
-        "/",
-        slashLastIndex - 1,
-      );
-      if (slashBeforeLastIndex === -1) {
-        return url;
-      }
-      return `file://${resource.slice(0, slashBeforeLastIndex + 1)}`;
-    }
-    return `file://${resource.slice(0, slashLastIndex + 1)}`;
-  }
-  return new URL(url.endsWith("/") ? "../" : "./", url).href;
+  return findAncestorDirectoryUrl(currentUrl, (ancestorDirectoryUrl) => {
+    const potentialPackageJsonFileUrl = `${ancestorDirectoryUrl}package.json`;
+    return existsSync(new URL(potentialPackageJsonFileUrl));
+  });
 };

package/src/kitchen/url_graph/url_info_transformations.js

@@ -275,7 +275,7 @@ export const createUrlInfoTransformer = ({
       contentIsInlined = false;
     }
     if (!contentIsInlined) {
-      writeFileSync(new URL(generatedUrl), urlInfo.content);
+      writeFileSync(new URL(generatedUrl), urlInfo.content, { force: true });
     }
     const { sourcemapGeneratedUrl, sourcemapReference } = urlInfo;
     if (sourcemapGeneratedUrl && sourcemapReference) {

package/src/plugins/protocol_file/jsenv_plugin_protocol_file.js

@@ -11,6 +11,7 @@ import {
 } 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 { jsenvPluginFsRedirection } from "./jsenv_plugin_fs_redirection.js";
 
@@ -83,6 +84,7 @@ export const jsenvPluginProtocolFile = ({
         if (!urlInfo.url.startsWith("file:")) {
           return null;
         }
+        const { rootDirectoryUrl } = urlInfo.context;
         const generateContent = () => {
           const urlObject = new URL(urlInfo.url);
           const { firstReference } = urlInfo;
@@ -101,11 +103,12 @@ export const jsenvPluginProtocolFile = ({
               : false;
             if (acceptsHtml) {
               firstReference.expectedType = "html";
-              const html = generateHtmlForDirectory(
-                urlObject.href,
-                directoryContentArray,
-                urlInfo.context.rootDirectoryUrl,
+              const directoryUrl = urlObject.href;
+              const directoryContentItems = generateDirectoryContentItems(
+                directoryUrl,
+                rootDirectoryUrl,
               );
+              const html = generateHtmlForDirectory(directoryContentItems);
               return {
                 type: "html",
                 contentType: "text/html",
@@ -138,32 +141,13 @@ export const jsenvPluginProtocolFile = ({
             if (e.code !== "ENOENT") {
               throw e;
             }
-            const rootDirectoryUrl = urlInfo.context.rootDirectoryUrl;
-            let firstExistingAncestorDirectoryUrl = new URL("./", urlInfo.url);
-            while (!existsSync(firstExistingAncestorDirectoryUrl)) {
-              firstExistingAncestorDirectoryUrl = new URL(
-                "../",
-                firstExistingAncestorDirectoryUrl,
-              );
-              if (
-                !urlIsInsideOf(
-                  firstExistingAncestorDirectoryUrl,
-                  rootDirectoryUrl,
-                )
-              ) {
-                firstExistingAncestorDirectoryUrl = rootDirectoryUrl;
-                break;
-              }
-            }
-
-            const firstExistingAncestorDirectoryContent = readdirSync(
-              new URL(firstExistingAncestorDirectoryUrl),
+            const directoryContentItems = generateDirectoryContentItems(
+              urlInfo.url,
+              rootDirectoryUrl,
             );
             const html = generateHtmlForENOENT(
               urlInfo.url,
-              firstExistingAncestorDirectoryContent,
-              firstExistingAncestorDirectoryUrl,
-              urlInfo.context.rootDirectoryUrl,
+              directoryContentItems,
               directoryListingUrlMocks,
             );
             return {
@@ -182,11 +166,9 @@ export const jsenvPluginProtocolFile = ({
   ];
 };
 
-const generateHtmlForDirectory = (
-  directoryUrl,
-  directoryContentArray,
-  rootDirectoryUrl,
-) => {
+const generateHtmlForDirectory = (directoryContentItems) => {
+  let directoryUrl = directoryContentItems.firstExistingDirectoryUrl;
+  const rootDirectoryUrl = directoryContentItems.rootDirectoryUrl;
   directoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl);
 
   const htmlForDirectory = String(readFileSync(htmlFileUrlForDirectory));
@@ -195,23 +177,19 @@ const generateHtmlForDirectory = (
     directoryUrl,
     directoryNav: () =>
       generateDirectoryNav(directoryRelativeUrl, rootDirectoryUrl),
-    directoryContent: () =>
-      generateDirectoryContent(
-        directoryContentArray,
-        directoryUrl,
-        rootDirectoryUrl,
-      ),
+    directoryContent: () => generateDirectoryContent(directoryContentItems),
   };
   const html = replacePlaceholders(htmlForDirectory, replacers);
   return html;
 };
 const generateHtmlForENOENT = (
   url,
-  ancestorDirectoryContentArray,
-  ancestorDirectoryUrl,
-  rootDirectoryUrl,
+  directoryContentItems,
   directoryListingUrlMocks,
 ) => {
+  const ancestorDirectoryUrl = directoryContentItems.firstExistingDirectoryUrl;
+  const rootDirectoryUrl = directoryContentItems.rootDirectoryUrl;
+
   const htmlFor404AndAncestorDir = String(
     readFileSync(html404AndAncestorDirFileUrl),
   );
@@ -230,11 +208,7 @@ const generateHtmlForENOENT = (
     ancestorDirectoryNav: () =>
       generateDirectoryNav(ancestorDirectoryRelativeUrl, rootDirectoryUrl),
     ancestorDirectoryContent: () =>
-      generateDirectoryContent(
-        ancestorDirectoryContentArray,
-        ancestorDirectoryUrl,
-        rootDirectoryUrl,
-      ),
+      generateDirectoryContent(directoryContentItems),
   };
   const html = replacePlaceholders(htmlFor404AndAncestorDir, replacers);
   return html;
@@ -276,31 +250,95 @@ const generateDirectoryNav = (relativeUrl, rootDirectoryUrl) => {
   }
   return dirPartsHtml;
 };
-const generateDirectoryContent = (
-  directoryContentArray,
-  directoryUrl,
-  rootDirectoryUrl,
-) => {
-  if (directoryContentArray.length === 0) {
-    return `<p>Directory is empty</p>`;
+const generateDirectoryContentItems = (directoryUrl, rootDirectoryUrl) => {
+  let firstExistingDirectoryUrl = new URL("./", directoryUrl);
+  while (!existsSync(firstExistingDirectoryUrl)) {
+    firstExistingDirectoryUrl = new URL("../", firstExistingDirectoryUrl);
+    if (!urlIsInsideOf(firstExistingDirectoryUrl, rootDirectoryUrl)) {
+      firstExistingDirectoryUrl = new URL(rootDirectoryUrl);
+      break;
+    }
   }
-  const sortedNames = [];
+  const directoryContentArray = readdirSync(firstExistingDirectoryUrl);
+  const fileUrls = [];
   for (const filename of directoryContentArray) {
-    const fileUrlObject = new URL(filename, directoryUrl);
-    if (lstatSync(fileUrlObject).isDirectory()) {
-      sortedNames.push(`${filename}/`);
+    const fileUrlObject = new URL(filename, firstExistingDirectoryUrl);
+    fileUrls.push(fileUrlObject);
+  }
+  package_workspaces: {
+    if (String(firstExistingDirectoryUrl) !== String(rootDirectoryUrl)) {
+      break package_workspaces;
+    }
+    const packageDirectoryUrl = lookupPackageDirectory(rootDirectoryUrl);
+    if (!packageDirectoryUrl) {
+      break package_workspaces;
+    }
+    if (String(packageDirectoryUrl) === String(rootDirectoryUrl)) {
+      break package_workspaces;
+    }
+    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 {
-      sortedNames.push(filename);
+      sortedUrls.push(fileUrl);
     }
   }
-  sortedNames.sort(comparePathnames);
-  let html = `<ul class="directory_content">`;
-  for (const filename of sortedNames) {
-    const fileUrlObject = new URL(filename, directoryUrl);
-    const fileUrl = String(fileUrlObject);
-    const fileUrlRelativeToParent = urlToRelativeUrl(fileUrl, directoryUrl);
-    const fileUrlRelativeToRoot = urlToRelativeUrl(fileUrl, rootDirectoryUrl);
+  sortedUrls.sort((a, b) => {
+    return comparePathnames(a.pathname, b.pathname);
+  });
+
+  const items = [];
+  for (const sortedUrl of sortedUrls) {
+    const fileUrlRelativeToParent = urlToRelativeUrl(
+      sortedUrl,
+      firstExistingDirectoryUrl,
+    );
+    const fileUrlRelativeToRoot = urlToRelativeUrl(sortedUrl, rootDirectoryUrl);
     const type = fileUrlRelativeToParent.endsWith("/") ? "dir" : "file";
+    items.push({
+      type,
+      fileUrlRelativeToParent,
+      fileUrlRelativeToRoot,
+    });
+  }
+  items.rootDirectoryUrl = rootDirectoryUrl;
+  items.firstExistingDirectoryUrl = firstExistingDirectoryUrl;
+  return items;
+};
+const generateDirectoryContent = (directoryContentItems) => {
+  if (directoryContentItems.length === 0) {
+    return `<p>Directory is empty</p>`;
+  }
+  let html = `<ul class="directory_content">`;
+  for (const directoryContentItem of directoryContentItems) {
+    const { type, fileUrlRelativeToParent, fileUrlRelativeToRoot } =
+      directoryContentItem;
     html += `
       <li class="directory_child" data-type="${type}">
         <a href="/${fileUrlRelativeToRoot}">${fileUrlRelativeToParent}</a>