@jsenv/filesystem 4.11.0 → 4.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/filesystem",
-  "version": "4.11.0",
+  "version": "4.13.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/lifecycle/register_directory_lifecycle.js

@@ -339,7 +339,8 @@ export const registerDirectoryLifecycle = (
     }
   };
 
-  readdirSync(new URL(sourceUrl)).forEach((entry) => {
+  const entries = readdirSync(new URL(sourceUrl));
+  for (const entry of entries) {
     const entryUrl = new URL(entry, sourceUrl).href;
     const entryInfo = readEntryInfo(entryUrl);
     if (entryInfo.type !== null && entryInfo.patternValue) {
@@ -347,7 +348,7 @@ export const registerDirectoryLifecycle = (
         notify: notifyExistent,
       });
     }
-  });
+  }
   if (debug) {
     const relativeUrls = Array.from(infoMap.keys());
     if (relativeUrls.length === 0) {
@@ -381,11 +382,11 @@ const shouldCallUpdated = (entryInfo) => {
   if (!stat.atimeMs) {
     return true;
   }
-  if (stat.atimeMs < stat.mtimeMs) {
+  if (stat.atimeMs <= stat.mtimeMs) {
     return true;
   }
-  if (isLinux && stat.mtimeMs <= previousInfo.stat.mtimeMs) {
-    return false;
+  if (stat.mtimeMs !== previousInfo.stat.mtimeMs) {
+    return true;
   }
   return true;
 };

package/src/lifecycle/register_file_lifecycle.js

@@ -8,6 +8,10 @@ import { createWatcher } from "./create_watcher.js";
 import { guardTooFastSecondCall } from "./guard_second_call.js";
 import { trackResources } from "./track_resources.js";
 
+const isMacos = process.platform === "darwin";
+const isLinux = process.platform === "linux";
+const isFreeBSD = process.platform === "freebsd";
+
 export const registerFileLifecycle = (
   source,
   {
@@ -171,16 +175,13 @@ const watchFileMutation = (
   { updated, removed, keepProcessAlive, stat },
 ) => {
   let prevStat = stat;
-  let watcher = createWatcher(urlToFileSystemPath(sourceUrl), {
-    persistent: keepProcessAlive,
-  });
+  let watcher;
 
-  watcher.on("change", () => {
+  const onChange = () => {
     const { type, stat } = readFileInfo(sourceUrl);
 
     if (type === null) {
-      watcher.close();
-      watcher = undefined;
+      stopWatching();
       if (removed) {
         removed();
       }
@@ -188,25 +189,38 @@ const watchFileMutation = (
       if (updated && shouldCallUpdated(stat, prevStat)) {
         updated();
       }
+      if ((isMacos || isLinux || isFreeBSD) && prevStat.ino !== stat.ino) {
+        stopWatching();
+        watch();
+      }
     }
     prevStat = stat;
-  });
+  };
 
-  return () => {
+  const watch = () => {
+    watcher = createWatcher(urlToFileSystemPath(sourceUrl), {
+      persistent: keepProcessAlive,
+    });
+    watcher.on("change", onChange);
+  };
+  const stopWatching = () => {
     if (watcher) {
       watcher.close();
+      watcher = undefined;
     }
   };
+  watch();
+  return stopWatching;
 };
 
 const shouldCallUpdated = (stat, prevStat) => {
   if (!stat.atimeMs) {
     return true;
   }
-  if (stat.atimeMs < stat.mtimeMs) {
+  if (stat.atimeMs <= stat.mtimeMs) {
     return true;
   }
-  if (stat.mtimeMs > prevStat.mtimeMs) {
+  if (stat.mtimeMs !== prevStat.mtimeMs) {
     return true;
   }
   return false;

package/src/main.js

@@ -17,6 +17,8 @@ export {
 } from "./path_and_url/file_url_validation.js";
 export { comparePathnames } from "./path_and_url/compare_pathnames.js";
 export { ensureWindowsDriveLetter } from "./path_and_url/ensure_windows_drive_letter.js";
+export { getParentDirectoryUrl } from "./path_and_url/get_parent_directory_url.js";
+export { findAncestorDirectoryUrl } from "./path_and_url/find_ancestor_directory_url.js";
 
 // list
 export { collectDirectoryMatchReport } from "./list/collect_directory_match_report.js";

package/src/path_and_url/find_ancestor_directory_url.js

@@ -0,0 +1,12 @@
+import { getParentDirectoryUrl } from "./get_parent_directory_url.js";
+
+export const findAncestorDirectoryUrl = (url, callback) => {
+  url = String(url);
+  while (url !== "file:///") {
+    if (callback(url)) {
+      return url;
+    }
+    url = getParentDirectoryUrl(url);
+  }
+  return null;
+};

package/src/path_and_url/get_parent_directory_url.js

@@ -0,0 +1,24 @@
+export 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;
+};

package/src/read_write/write_directory_sync.js

@@ -1,21 +1,59 @@
 import { urlToFileSystemPath } from "@jsenv/urls";
-import { mkdirSync } from "node:fs";
+import { mkdirSync, statSync, unlinkSync } from "node:fs";
 
 import { assertAndNormalizeDirectoryUrl } from "../path_and_url/directory_url_validation.js";
+import { findAncestorDirectoryUrl } from "../path_and_url/find_ancestor_directory_url.js";
 import { readEntryStatSync } from "./stat/read_entry_stat_sync.js";
 import { statsToType } from "./stat/stats_to_type.js";
 
 export const writeDirectorySync = (
   destination,
-  { recursive = true, allowUseless = false } = {},
+  { recursive = true, allowUseless = false, force } = {},
 ) => {
   const destinationUrl = assertAndNormalizeDirectoryUrl(destination);
   const destinationPath = urlToFileSystemPath(destinationUrl);
 
-  const destinationStats = readEntryStatSync(destinationUrl, {
-    nullIfNotFound: true,
-    followLink: false,
-  });
+  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()) {
@@ -24,7 +62,6 @@ export const writeDirectorySync = (
       }
       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}`,

package/src/read_write/write_file_sync.js

@@ -1,12 +1,10 @@
-import {
-  mkdirSync,
-  readFileSync,
-  writeFileSync as writeFileSyncNode,
-} from "node:fs";
+import { readFileSync, writeFileSync as writeFileSyncNode } from "node:fs";
 
 import { assertAndNormalizeFileUrl } from "../path_and_url/file_url_validation.js";
+import { removeDirectorySync } from "../remove/remove_directory_sync.js";
+import { writeDirectorySync } from "./write_directory_sync.js";
 
-export const writeFileSync = (destination, content = "") => {
+export const writeFileSync = (destination, content = "", { force } = {}) => {
   const destinationUrl = assertAndNormalizeFileUrl(destination);
   const destinationUrlObject = new URL(destinationUrl);
   if (content && content instanceof URL) {
@@ -15,8 +13,18 @@ export const writeFileSync = (destination, content = "") => {
   try {
     writeFileSyncNode(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);
+        writeFileSyncNode(destinationUrlObject, content);
+      } else {
+        throw error;
+      }
+    }
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+      writeDirectorySync(new URL("./", destinationUrlObject), {
+        force,
         recursive: true,
       });
       writeFileSyncNode(destinationUrlObject, content);