@jsenv/test 3.5.31 → 3.5.33

package/dist/jsenv_test.js

@@ -4,7 +4,7 @@ import tty from "node:tty";
 import stringWidth from "string-width";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import { URL_META, filterV8Coverage } from "./js/v8_coverage.js";
-import { readdir, chmod, stat, lstat, chmodSync, statSync, lstatSync, promises, readFile as readFile$1, readFileSync, writeFileSync as writeFileSync$1, mkdirSync, unlink, openSync, closeSync, rmdir, unlinkSync, readdirSync, rmdirSync, existsSync } from "node:fs";
+import { readdir, chmod, stat, lstat, chmodSync, statSync, lstatSync, promises, readFile as readFile$1, unlinkSync, openSync, closeSync, readdirSync, rmdirSync, mkdirSync, readFileSync, writeFileSync as writeFileSync$1, unlink, rmdir, existsSync } from "node:fs";
 import { dirname } from "node:path";
 import crypto from "node:crypto";
 import { readGitHubWorkflowEnv, startGithubCheckRun } from "@jsenv/github-check-run";
@@ -578,17 +578,29 @@ if (
 }
 
 function envForceColor() {
-	if ('FORCE_COLOR' in env) {
-		if (env.FORCE_COLOR === 'true') {
-			return 1;
-		}
+	if (!('FORCE_COLOR' in env)) {
+		return;
+	}
 
-		if (env.FORCE_COLOR === 'false') {
-			return 0;
-		}
+	if (env.FORCE_COLOR === 'true') {
+		return 1;
+	}
+
+	if (env.FORCE_COLOR === 'false') {
+		return 0;
+	}
+
+	if (env.FORCE_COLOR.length === 0) {
+		return 1;
+	}
 
-		return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+	const level = Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+
+	if (![0, 1, 2, 3].includes(level)) {
+		return;
 	}
+
+	return level;
 }
 
 function translateLevel(level) {
@@ -659,11 +671,11 @@ function _supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) {
 	}
 
 	if ('CI' in env) {
-		if ('GITHUB_ACTIONS' in env || 'GITEA_ACTIONS' in env) {
+		if (['GITHUB_ACTIONS', 'GITEA_ACTIONS', 'CIRCLECI'].some(key => key in env)) {
 			return 3;
 		}
 
-		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+		if (['TRAVIS', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
 			return 1;
 		}
 
@@ -2120,6 +2132,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 readDirectory = async (url, { emfileMaxWait = 1000 } = {}) => {
   const directoryUrl = assertAndNormalizeDirectoryUrl(url);
   const directoryUrlObject = new URL(directoryUrl);
@@ -2542,7 +2590,284 @@ const readFile = async (value, { as = "buffer" } = {}) => {
   );
 };
 
-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(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) {
@@ -2551,8 +2876,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);
@@ -2600,7 +2935,7 @@ const removeEntry = async (
       sourceStats.isCharacterDevice() ||
       sourceStats.isBlockDevice()
     ) {
-      await removeNonDirectory$1(
+      await removeNonDirectory(
         sourceUrl.endsWith("/") ? sourceUrl.slice(0, -1) : sourceUrl,
         {
           maxRetries,
@@ -2621,7 +2956,7 @@ const removeEntry = async (
   }
 };
 
-const removeNonDirectory$1 = (sourceUrl, { maxRetries, retryDelay }) => {
+const removeNonDirectory = (sourceUrl, { maxRetries, retryDelay }) => {
   const sourcePath = urlToFileSystemPath(sourceUrl);
 
   let retryCount = 0;
@@ -2760,11 +3095,11 @@ const removeDirectory = async (
   };
 
   const visitFile = async (fileUrl) => {
-    await removeNonDirectory$1(fileUrl, { maxRetries, retryDelay });
+    await removeNonDirectory(fileUrl, { maxRetries, retryDelay });
   };
 
   const visitSymbolicLink = async (symbolicLinkUrl) => {
-    await removeNonDirectory$1(symbolicLinkUrl, { maxRetries, retryDelay });
+    await removeNonDirectory(symbolicLinkUrl, { maxRetries, retryDelay });
   };
 
   try {
@@ -2809,240 +3144,6 @@ const removeDirectoryNaive = (
 
 process.platform === "win32";
 
-const writeDirectorySync = (
-  destination,
-  { recursive = true, allowUseless = false } = {},
-) => {
-  const destinationUrl = assertAndNormalizeDirectoryUrl(destination);
-  const destinationPath = urlToFileSystemPath(destinationUrl);
-
-  const destinationStats = readEntryStatSync(destinationUrl, {
-    nullIfNotFound: true,
-    followLink: false,
-  });
-
-  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 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(
-      sourceUrl.endsWith("/") ? sourceUrl.slice(0, -1) : sourceUrl);
-  } else if (sourceStats.isDirectory()) {
-    const directoryUrl = ensurePathnameTrailingSlash(sourceUrl);
-    removeDirectorySync(directoryUrl, {
-      recursive,
-      maxRetries,
-      retryDelay,
-      onlyContent,
-    });
-  }
-};
-
-const removeNonDirectory = (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 = (
-  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(entryName, directoryUrl);
-      visit(url);
-    }
-  };
-
-  const visitFile = (fileUrl) => {
-    removeNonDirectory(fileUrl);
-  };
-
-  const visitSymbolicLink = (symbolicLinkUrl) => {
-    removeNonDirectory(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;
-  }
-};
-
 process.platform === "win32";
 
 const ensureEmptyDirectorySync = (source) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/test",
-  "version": "3.5.31",
+  "version": "3.5.33",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -39,12 +39,12 @@
     "@jsenv/abort": "4.3.0",
     "@jsenv/ast": "6.4.1",
     "@jsenv/exception": "1.1.3",
-    "@jsenv/filesystem": "4.11.0",
+    "@jsenv/filesystem": "4.12.0",
     "@jsenv/github-check-run": "0.2.5",
     "@jsenv/node-esm-resolution": "1.0.6",
     "@jsenv/humanize": "1.2.8",
-    "@jsenv/plugin-supervisor": "1.6.0",
-    "@jsenv/sourcemap": "1.2.28",
+    "@jsenv/plugin-supervisor": "1.6.1",
+    "@jsenv/sourcemap": "1.2.29",
     "@jsenv/url-meta": "8.5.2",
     "@jsenv/urls": "2.5.4",
     "@jsenv/utils": "2.1.2",
@@ -55,7 +55,7 @@
     "istanbul-reports": "3.1.7",
     "pidtree": "0.6.0",
     "strip-ansi": "7.1.0",
-    "supports-color": "9.4.0",
+    "supports-color": "10.0.0",
     "v8-to-istanbul": "9.3.0"
   }
 }