@jsenv/filesystem 4.2.3 → 4.2.4

package/README.md

@@ -5,7 +5,7 @@ Collection of functions to interact with filesystem in Node.js
 ## List files using pattern matching
 
 ```js
-import { listFilesMatching } from "@jsenv/filesystem"
+import { listFilesMatching } from "@jsenv/filesystem";
 
 const jsFiles = await listFilesMatching({
   directoryUrl: new URL("./", import.meta.url),
@@ -13,7 +13,7 @@ const jsFiles = await listFilesMatching({
     "./**/*.js": true,
     "./**/*.test.js": false,
   },
-})
+});
 ```
 
 ```console
@@ -26,45 +26,45 @@ const jsFiles = await listFilesMatching({
 ## Watch a specific file changes
 
 ```js
-import { readFileSync } from "node:fs"
-import { registerFileLifecycle } from "@jsenv/filesystem"
+import { readFileSync } from "node:fs";
+import { registerFileLifecycle } from "@jsenv/filesystem";
 
-const packageJSONFileUrl = new URL("./package.json", import.meta.url)
-let packageJSON = null
+const packageJSONFileUrl = new URL("./package.json", import.meta.url);
+let packageJSON = null;
 const unregister = registerFileLifecycle(packageJSONFileUrl, {
   added: () => {
-    packageJSON = JSON.parse(String(readFileSync(packageJSONFileUrl)))
+    packageJSON = JSON.parse(String(readFileSync(packageJSONFileUrl)));
   },
   updated: () => {
-    packageJSON = JSON.parse(String(readFileSync(packageJSONFileUrl)))
+    packageJSON = JSON.parse(String(readFileSync(packageJSONFileUrl)));
   },
   removed: () => {
-    packageJSON = null
+    packageJSON = null;
   },
   notifyExistent: true,
-})
-unregister() // stop watching the file changes
+});
+unregister(); // stop watching the file changes
 ```
 
 ## Watch many files changes
 
 ```js
-import { registerDirectoryLifecycle } from "@jsenv/filesystem"
+import { registerDirectoryLifecycle } from "@jsenv/filesystem";
 
-const directoryContentDescription = {}
+const directoryContentDescription = {};
 const unregister = registerDirectoryLifecycle("file:///directory/", {
   watchPatterns: {
     "./**/*": true,
     "./node_modules/": false,
   },
   added: ({ relativeUrl, type }) => {
-    directoryContentDescription[relativeUrl] = type
+    directoryContentDescription[relativeUrl] = type;
   },
   removed: ({ relativeUrl }) => {
-    delete directoryContentDescription[relativeUrl]
+    delete directoryContentDescription[relativeUrl];
   },
-})
-unregister() // stop watching the directory changes
+});
+unregister(); // stop watching the directory changes
 ```
 
 # API

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@jsenv/filesystem",
-  "version": "4.2.3",
+  "version": "4.2.4",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jsenv/jsenv-core",
-    "directory": "packages/filesystem"
+    "url": "https://github.com/jsenv/core",
+    "directory": "packages/independent/filesystem"
   },
   "publishConfig": {
     "access": "public"
@@ -29,7 +29,7 @@
     "test": "node --conditions=development ./scripts/test.mjs"
   },
   "dependencies": {
-    "@jsenv/urls": "2.0.0",
+    "@jsenv/urls": "2.1.0",
     "@jsenv/url-meta": "8.1.0",
     "@jsenv/abort": "4.2.4"
   }

package/src/assertDirectoryPresence.js

@@ -1,24 +1,24 @@
-import { urlToFileSystemPath } from "@jsenv/urls"
+import { urlToFileSystemPath } from "@jsenv/urls";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
-import { statsToType } from "./internal/statsToType.js"
-import { readEntryStat } from "./readEntryStat.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { statsToType } from "./internal/statsToType.js";
+import { readEntryStat } from "./readEntryStat.js";
 
 export const assertDirectoryPresence = async (source) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source)
-  const sourcePath = urlToFileSystemPath(sourceUrl)
+  const sourceUrl = assertAndNormalizeFileUrl(source);
+  const sourcePath = urlToFileSystemPath(sourceUrl);
 
   const sourceStats = await readEntryStat(sourceUrl, {
     nullIfNotFound: true,
-  })
+  });
   if (!sourceStats) {
-    throw new Error(`directory not found at ${sourcePath}`)
+    throw new Error(`directory not found at ${sourcePath}`);
   }
   if (!sourceStats.isDirectory()) {
     throw new Error(
       `directory expected at ${sourcePath} and found ${statsToType(
         sourceStats,
       )} instead`,
-    )
+    );
   }
-}
+};

package/src/assertFilePresence.js

@@ -1,24 +1,24 @@
-import { urlToFileSystemPath } from "@jsenv/urls"
+import { urlToFileSystemPath } from "@jsenv/urls";
 
-import { assertAndNormalizeFileUrl } from "./file_url_validation.js"
-import { statsToType } from "./internal/statsToType.js"
-import { readEntryStat } from "./readEntryStat.js"
+import { assertAndNormalizeFileUrl } from "./file_url_validation.js";
+import { statsToType } from "./internal/statsToType.js";
+import { readEntryStat } from "./readEntryStat.js";
 
 export const assertFilePresence = async (source) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source)
-  const sourcePath = urlToFileSystemPath(sourceUrl)
+  const sourceUrl = assertAndNormalizeFileUrl(source);
+  const sourcePath = urlToFileSystemPath(sourceUrl);
 
   const sourceStats = await readEntryStat(sourceUrl, {
     nullIfNotFound: true,
-  })
+  });
   if (!sourceStats) {
-    throw new Error(`file not found at ${sourcePath}`)
+    throw new Error(`file not found at ${sourcePath}`);
   }
   if (!sourceStats.isFile()) {
     throw new Error(
       `file expected at ${sourcePath} and found ${statsToType(
         sourceStats,
       )} instead`,
-    )
+    );
   }
-}
+};

package/src/bufferToEtag.js

@@ -5,25 +5,25 @@
  *   https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag
  */
 
-import { createHash } from "node:crypto"
+import { createHash } from "node:crypto";
 
-const ETAG_FOR_EMPTY_CONTENT = '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"'
+const ETAG_FOR_EMPTY_CONTENT = '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"';
 
 export const bufferToEtag = (buffer) => {
   if (!Buffer.isBuffer(buffer)) {
-    throw new TypeError(`buffer expected, got ${buffer}`)
+    throw new TypeError(`buffer expected, got ${buffer}`);
   }
 
   if (buffer.length === 0) {
-    return ETAG_FOR_EMPTY_CONTENT
+    return ETAG_FOR_EMPTY_CONTENT;
   }
 
-  const hash = createHash("sha1")
-  hash.update(buffer, "utf8")
+  const hash = createHash("sha1");
+  hash.update(buffer, "utf8");
 
-  const hashBase64String = hash.digest("base64")
-  const hashBase64StringSubset = hashBase64String.slice(0, 27)
-  const length = buffer.length
+  const hashBase64String = hash.digest("base64");
+  const hashBase64StringSubset = hashBase64String.slice(0, 27);
+  const length = buffer.length;
 
-  return `"${length.toString(16)}-${hashBase64StringSubset}"`
-}
+  return `"${length.toString(16)}-${hashBase64StringSubset}"`;
+};

package/src/collectDirectoryMatchReport.js

@@ -1,11 +1,11 @@
-import { Abort } from "@jsenv/abort"
+import { Abort } from "@jsenv/abort";
 
-import { URL_META } from "@jsenv/url-meta"
-import { urlToRelativeUrl } from "@jsenv/urls"
-import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js"
-import { readDirectory } from "./readDirectory.js"
-import { readEntryStat } from "./readEntryStat.js"
-import { comparePathnames } from "./comparePathnames.js"
+import { URL_META } from "@jsenv/url-meta";
+import { urlToRelativeUrl } from "@jsenv/urls";
+import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js";
+import { readDirectory } from "./readDirectory.js";
+import { readEntryStat } from "./readEntryStat.js";
+import { comparePathnames } from "./comparePathnames.js";
 
 export const collectDirectoryMatchReport = async ({
   signal = new AbortController().signal,
@@ -13,31 +13,31 @@ export const collectDirectoryMatchReport = async ({
   associations,
   predicate,
 }) => {
-  const matchingArray = []
-  const ignoredArray = []
+  const matchingArray = [];
+  const ignoredArray = [];
 
-  const rootDirectoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl)
+  const rootDirectoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl);
   if (typeof predicate !== "function") {
-    throw new TypeError(`predicate must be a function, got ${predicate}`)
+    throw new TypeError(`predicate must be a function, got ${predicate}`);
   }
-  associations = URL_META.resolveAssociations(associations, rootDirectoryUrl)
+  associations = URL_META.resolveAssociations(associations, rootDirectoryUrl);
 
-  const collectOperation = Abort.startOperation()
-  collectOperation.addAbortSignal(signal)
+  const collectOperation = Abort.startOperation();
+  collectOperation.addAbortSignal(signal);
 
   const visitDirectory = async (directoryUrl) => {
-    collectOperation.throwIfAborted()
-    const directoryItems = await readDirectory(directoryUrl)
+    collectOperation.throwIfAborted();
+    const directoryItems = await readDirectory(directoryUrl);
 
     await Promise.all(
       directoryItems.map(async (directoryItem) => {
-        const directoryChildNodeUrl = `${directoryUrl}${directoryItem}`
+        const directoryChildNodeUrl = `${directoryUrl}${directoryItem}`;
         const relativeUrl = urlToRelativeUrl(
           directoryChildNodeUrl,
           rootDirectoryUrl,
-        )
+        );
 
-        collectOperation.throwIfAborted()
+        collectOperation.throwIfAborted();
         const directoryChildNodeStats = await readEntryStat(
           directoryChildNodeUrl,
           {
@@ -49,10 +49,10 @@ export const collectDirectoryMatchReport = async ({
             // because directoryPath is recursively traversed
             followLink: false,
           },
-        )
+        );
 
         if (directoryChildNodeStats.isDirectory()) {
-          const subDirectoryUrl = `${directoryChildNodeUrl}/`
+          const subDirectoryUrl = `${directoryChildNodeUrl}/`;
 
           if (
             !URL_META.urlChildMayMatch({
@@ -66,53 +66,53 @@ export const collectDirectoryMatchReport = async ({
                 ? relativeUrl
                 : `${relativeUrl}/`,
               fileStats: directoryChildNodeStats,
-            })
+            });
 
-            return
+            return;
           }
 
-          await visitDirectory(subDirectoryUrl)
-          return
+          await visitDirectory(subDirectoryUrl);
+          return;
         }
 
         if (directoryChildNodeStats.isFile()) {
           const meta = URL_META.applyAssociations({
             url: directoryChildNodeUrl,
             associations,
-          })
+          });
           if (!predicate(meta)) {
             ignoredArray.push({
               relativeUrl,
               meta,
               fileStats: directoryChildNodeStats,
-            })
-            return
+            });
+            return;
           }
 
           matchingArray.push({
             relativeUrl,
             meta,
             fileStats: directoryChildNodeStats,
-          })
-          return
+          });
+          return;
         }
       }),
-    )
-  }
+    );
+  };
 
   try {
-    await visitDirectory(rootDirectoryUrl)
+    await visitDirectory(rootDirectoryUrl);
 
     return {
       matchingArray: sortByRelativeUrl(matchingArray),
       ignoredArray: sortByRelativeUrl(ignoredArray),
-    }
+    };
   } finally {
-    await collectOperation.end()
+    await collectOperation.end();
   }
-}
+};
 
 const sortByRelativeUrl = (array) =>
   array.sort((left, right) => {
-    return comparePathnames(left.relativeUrl, right.relativeUrl)
-  })
+    return comparePathnames(left.relativeUrl, right.relativeUrl);
+  });

package/src/collectFiles.js

@@ -1,11 +1,11 @@
-import { Abort } from "@jsenv/abort"
-import { URL_META } from "@jsenv/url-meta"
-import { urlToRelativeUrl } from "@jsenv/urls"
+import { Abort } from "@jsenv/abort";
+import { URL_META } from "@jsenv/url-meta";
+import { urlToRelativeUrl } from "@jsenv/urls";
 
-import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js"
-import { readDirectory } from "./readDirectory.js"
-import { readEntryStat } from "./readEntryStat.js"
-import { comparePathnames } from "./comparePathnames.js"
+import { assertAndNormalizeDirectoryUrl } from "./directory_url_validation.js";
+import { readDirectory } from "./readDirectory.js";
+import { readEntryStat } from "./readEntryStat.js";
+import { comparePathnames } from "./comparePathnames.js";
 
 export const collectFiles = async ({
   signal = new AbortController().signal,
@@ -13,24 +13,24 @@ export const collectFiles = async ({
   associations,
   predicate,
 }) => {
-  const rootDirectoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl)
+  const rootDirectoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl);
   if (typeof predicate !== "function") {
-    throw new TypeError(`predicate must be a function, got ${predicate}`)
+    throw new TypeError(`predicate must be a function, got ${predicate}`);
   }
-  associations = URL_META.resolveAssociations(associations, rootDirectoryUrl)
+  associations = URL_META.resolveAssociations(associations, rootDirectoryUrl);
 
-  const collectOperation = Abort.startOperation()
-  collectOperation.addAbortSignal(signal)
+  const collectOperation = Abort.startOperation();
+  collectOperation.addAbortSignal(signal);
 
-  const matchingFileResultArray = []
+  const matchingFileResultArray = [];
   const visitDirectory = async (directoryUrl) => {
-    collectOperation.throwIfAborted()
-    const directoryItems = await readDirectory(directoryUrl)
+    collectOperation.throwIfAborted();
+    const directoryItems = await readDirectory(directoryUrl);
 
     await Promise.all(
       directoryItems.map(async (directoryItem) => {
-        const directoryChildNodeUrl = `${directoryUrl}${directoryItem}`
-        collectOperation.throwIfAborted()
+        const directoryChildNodeUrl = `${directoryUrl}${directoryItem}`;
+        collectOperation.throwIfAborted();
         const directoryChildNodeStats = await readEntryStat(
           directoryChildNodeUrl,
           {
@@ -42,10 +42,10 @@ export const collectFiles = async ({
             // because directoryPath is recursively traversed
             followLink: false,
           },
-        )
+        );
 
         if (directoryChildNodeStats.isDirectory()) {
-          const subDirectoryUrl = `${directoryChildNodeUrl}/`
+          const subDirectoryUrl = `${directoryChildNodeUrl}/`;
           if (
             !URL_META.urlChildMayMatch({
               url: subDirectoryUrl,
@@ -53,47 +53,47 @@ export const collectFiles = async ({
               predicate,
             })
           ) {
-            return
+            return;
           }
-          await visitDirectory(subDirectoryUrl)
-          return
+          await visitDirectory(subDirectoryUrl);
+          return;
         }
 
         if (directoryChildNodeStats.isFile()) {
           const meta = URL_META.applyAssociations({
             url: directoryChildNodeUrl,
             associations,
-          })
-          if (!predicate(meta)) return
+          });
+          if (!predicate(meta)) return;
 
           const relativeUrl = urlToRelativeUrl(
             directoryChildNodeUrl,
             rootDirectoryUrl,
-          )
+          );
           matchingFileResultArray.push({
             url: new URL(relativeUrl, rootDirectoryUrl).href,
             relativeUrl: decodeURIComponent(relativeUrl),
             meta,
             fileStats: directoryChildNodeStats,
-          })
-          return
+          });
+          return;
         }
       }),
-    )
-  }
+    );
+  };
 
   try {
-    await visitDirectory(rootDirectoryUrl)
+    await visitDirectory(rootDirectoryUrl);
 
     // When we operate on thoose files later it feels more natural
     // to perform operation in the same order they appear in the filesystem.
     // It also allow to get a predictable return value.
     // For that reason we sort matchingFileResultArray
     matchingFileResultArray.sort((leftFile, rightFile) => {
-      return comparePathnames(leftFile.relativeUrl, rightFile.relativeUrl)
-    })
-    return matchingFileResultArray
+      return comparePathnames(leftFile.relativeUrl, rightFile.relativeUrl);
+    });
+    return matchingFileResultArray;
   } finally {
-    await collectOperation.end()
+    await collectOperation.end();
   }
-}
+};

package/src/comparePathnames.js

@@ -1,49 +1,49 @@
 export const comparePathnames = (leftPathame, rightPathname) => {
-  const leftPartArray = leftPathame.split("/")
-  const rightPartArray = rightPathname.split("/")
+  const leftPartArray = leftPathame.split("/");
+  const rightPartArray = rightPathname.split("/");
 
-  const leftLength = leftPartArray.length
-  const rightLength = rightPartArray.length
+  const leftLength = leftPartArray.length;
+  const rightLength = rightPartArray.length;
 
-  const maxLength = Math.max(leftLength, rightLength)
-  let i = 0
+  const maxLength = Math.max(leftLength, rightLength);
+  let i = 0;
   while (i < maxLength) {
-    const leftPartExists = i in leftPartArray
-    const rightPartExists = i in rightPartArray
+    const leftPartExists = i in leftPartArray;
+    const rightPartExists = i in rightPartArray;
 
     // longer comes first
     if (!leftPartExists) {
-      return +1
+      return +1;
     }
     if (!rightPartExists) {
-      return -1
+      return -1;
     }
 
-    const leftPartIsLast = i === leftPartArray.length - 1
-    const rightPartIsLast = i === rightPartArray.length - 1
+    const leftPartIsLast = i === leftPartArray.length - 1;
+    const rightPartIsLast = i === rightPartArray.length - 1;
     // folder comes first
     if (leftPartIsLast && !rightPartIsLast) {
-      return +1
+      return +1;
     }
     if (!leftPartIsLast && rightPartIsLast) {
-      return -1
+      return -1;
     }
 
-    const leftPart = leftPartArray[i]
-    const rightPart = rightPartArray[i]
-    i++
+    const leftPart = leftPartArray[i];
+    const rightPart = rightPartArray[i];
+    i++;
     // local comparison comes first
-    const comparison = leftPart.localeCompare(rightPart)
+    const comparison = leftPart.localeCompare(rightPart);
     if (comparison !== 0) {
-      return comparison
+      return comparison;
     }
   }
 
   if (leftLength < rightLength) {
-    return +1
+    return +1;
   }
   if (leftLength > rightLength) {
-    return -1
+    return -1;
   }
-  return 0
-}
+  return 0;
+};