@jsenv/filesystem 2.4.0 → 2.6.1

package/README.md

@@ -18,10 +18,13 @@ console.log(relativeUrl) // "src/file.js"
 ```js
 import { listFilesMatching } from "@jsenv/filesystem"
 
-const jsFiles = await listFilesMatching(
-  "./**/*.js",
-  new URL("./", import.meta.url),
-)
+const jsFiles = await listFilesMatching({
+  directoryUrl: new URL("./", import.meta.url),
+  patterns: {
+    "./**/*.js": true,
+    "./**/*.test.js": false,
+  },
+})
 ```
 
 ```console

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/filesystem",
-  "version": "2.4.0",
+  "version": "2.6.1",
   "description": "Collection of functions to interact with filesystem in Node.js",
   "license": "MIT",
   "author": {
@@ -13,57 +13,46 @@
     "url": "https://github.com/jsenv/filesystem"
   },
   "engines": {
-    "node": ">=14.17.0"
+    "node": ">=16.13.0"
   },
   "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
+    "access": "public"
   },
   "type": "module",
   "exports": {
     ".": {
-      "import": "./main.js",
-      "require": "./dist/commonjs/jsenv_filesystem.cjs"
+      "import": "./main.js"
     },
     "./*": "./*"
   },
+  "main": "./main.js",
   "files": [
-    "/dist/",
     "/src/",
     "/main.js"
   ],
   "scripts": {
-    "eslint-check": "node ./node_modules/eslint/bin/eslint.js .",
-    "generate-importmap": "node ./script/importmap/generate_importmap.mjs",
-    "measure-performances": "node ./script/performance/generate_performance_report.mjs --local",
-    "dist": "npm run build",
-    "build": "node --experimental-import-meta-resolve ./script/build/build.mjs",
+    "eslint": "node ./node_modules/eslint/bin/eslint.js .",
+    "importmap": "node ./script/importmap/importmap.mjs",
+    "performance": "node --expose-gc ./script/performance/performance.mjs --log",
     "test": "node ./script/test/test.mjs",
     "test-with-coverage": "npm run test -- --coverage",
-    "prettier-format": "node ./script/prettier/prettier_format.mjs",
-    "prettier-format-stage": "npm run prettier-format -- --staged",
-    "prettier-check": "npm run prettier-format -- --dry-run",
-    "prepublishOnly": "node ./script/publish/remove_postinstall.mjs && npm run dist",
-    "postpublish": "node ./script/publish/restore_postinstall.mjs"
+    "prettier": "prettier --write ."
   },
   "dependencies": {
-    "@jsenv/cancellation": "3.0.0",
-    "@jsenv/url-meta": "6.0.1"
+    "@jsenv/abort": "4.1.2",
+    "@jsenv/url-meta": "6.0.3"
   },
   "devDependencies": {
-    "@babel/core": "7.16.0",
-    "@babel/eslint-parser": "7.16.0",
-    "@jsenv/assert": "2.3.2",
-    "@jsenv/core": "23.2.2",
-    "@jsenv/eslint-config": "16.0.8",
+    "@jsenv/assert": "2.4.1",
+    "@jsenv/core": "25.1.0",
+    "@jsenv/eslint-config": "16.0.9",
     "@jsenv/github-release-package": "1.2.3",
-    "@jsenv/importmap-eslint-resolver": "5.1.2",
-    "@jsenv/importmap-node-module": "2.4.1",
+    "@jsenv/importmap-eslint-resolver": "5.2.2",
+    "@jsenv/importmap-node-module": "5.1.0",
     "@jsenv/package-publish": "1.6.2",
     "@jsenv/performance-impact": "2.2.1",
-    "@jsenv/prettier-check-project": "5.6.1",
-    "eslint": "7.32.0",
-    "eslint-plugin-import": "2.25.2",
-    "prettier": "2.4.1"
+    "eslint": "8.6.0",
+    "eslint-plugin-import": "2.25.4",
+    "prettier": "2.5.1"
   }
-}
+}

package/src/collectDirectoryMatchReport.js

@@ -1,4 +1,4 @@
-import { createCancellationToken, createOperation } from "@jsenv/cancellation"
+import { Abort } from "@jsenv/abort"
 import {
   normalizeStructuredMetaMap,
   urlCanContainsMetaMatching,
@@ -13,7 +13,7 @@ import { urlToRelativeUrl } from "./urlToRelativeUrl.js"
 import { comparePathnames } from "./comparePathnames.js"
 
 export const collectDirectoryMatchReport = async ({
-  cancellationToken = createCancellationToken(),
+  signal = new AbortController().signal,
   directoryUrl,
   structuredMetaMap,
   predicate,
@@ -30,11 +30,12 @@ export const collectDirectoryMatchReport = async ({
     rootDirectoryUrl,
   )
 
+  const collectOperation = Abort.startOperation()
+  collectOperation.addAbortSignal(signal)
+
   const visitDirectory = async (directoryUrl) => {
-    const directoryItems = await createOperation({
-      cancellationToken,
-      start: () => readDirectory(directoryUrl),
-    })
+    collectOperation.throwIfAborted()
+    const directoryItems = await readDirectory(directoryUrl)
 
     await Promise.all(
       directoryItems.map(async (directoryItem) => {
@@ -44,19 +45,19 @@ export const collectDirectoryMatchReport = async ({
           rootDirectoryUrl,
         )
 
-        const directoryChildNodeStats = await createOperation({
-          cancellationToken,
-          start: () =>
-            readFileSystemNodeStat(directoryChildNodeUrl, {
-              // we ignore symlink because recursively traversed
-              // so symlinked file will be discovered.
-              // Moreover if they lead outside of directoryPath it can become a problem
-              // like infinite recursion of whatever.
-              // that we could handle using an object of pathname already seen but it will be useless
-              // because directoryPath is recursively traversed
-              followLink: false,
-            }),
-        })
+        collectOperation.throwIfAborted()
+        const directoryChildNodeStats = await readFileSystemNodeStat(
+          directoryChildNodeUrl,
+          {
+            // we ignore symlink because recursively traversed
+            // so symlinked file will be discovered.
+            // Moreover if they lead outside of directoryPath it can become a problem
+            // like infinite recursion of whatever.
+            // that we could handle using an object of pathname already seen but it will be useless
+            // because directoryPath is recursively traversed
+            followLink: false,
+          },
+        )
 
         if (directoryChildNodeStats.isDirectory()) {
           const subDirectoryUrl = `${directoryChildNodeUrl}/`
@@ -104,11 +105,16 @@ export const collectDirectoryMatchReport = async ({
       }),
     )
   }
-  await visitDirectory(rootDirectoryUrl)
 
-  return {
-    matchingArray: sortByRelativeUrl(matchingArray),
-    ignoredArray: sortByRelativeUrl(ignoredArray),
+  try {
+    await visitDirectory(rootDirectoryUrl)
+
+    return {
+      matchingArray: sortByRelativeUrl(matchingArray),
+      ignoredArray: sortByRelativeUrl(ignoredArray),
+    }
+  } finally {
+    await collectOperation.end()
   }
 }
 

package/src/collectFiles.js

@@ -1,4 +1,4 @@
-import { createCancellationToken, createOperation } from "@jsenv/cancellation"
+import { Abort } from "@jsenv/abort"
 import {
   normalizeStructuredMetaMap,
   urlCanContainsMetaMatching,
@@ -12,50 +12,45 @@ import { urlToRelativeUrl } from "./urlToRelativeUrl.js"
 import { comparePathnames } from "./comparePathnames.js"
 
 export const collectFiles = async ({
-  cancellationToken = createCancellationToken(),
+  signal = new AbortController().signal,
   directoryUrl,
   structuredMetaMap,
   predicate,
-  matchingFileOperation = () => null,
 }) => {
   const rootDirectoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl)
   if (typeof predicate !== "function") {
     throw new TypeError(`predicate must be a function, got ${predicate}`)
   }
-  if (typeof matchingFileOperation !== "function") {
-    throw new TypeError(
-      `matchingFileOperation must be a function, got ${matchingFileOperation}`,
-    )
-  }
   const structuredMetaMapNormalized = normalizeStructuredMetaMap(
     structuredMetaMap,
     rootDirectoryUrl,
   )
 
+  const collectOperation = Abort.startOperation()
+  collectOperation.addAbortSignal(signal)
+
   const matchingFileResultArray = []
   const visitDirectory = async (directoryUrl) => {
-    const directoryItems = await createOperation({
-      cancellationToken,
-      start: () => readDirectory(directoryUrl),
-    })
+    collectOperation.throwIfAborted()
+    const directoryItems = await readDirectory(directoryUrl)
 
     await Promise.all(
       directoryItems.map(async (directoryItem) => {
         const directoryChildNodeUrl = `${directoryUrl}${directoryItem}`
 
-        const directoryChildNodeStats = await createOperation({
-          cancellationToken,
-          start: () =>
-            readFileSystemNodeStat(directoryChildNodeUrl, {
-              // we ignore symlink because recursively traversed
-              // so symlinked file will be discovered.
-              // Moreover if they lead outside of directoryPath it can become a problem
-              // like infinite recursion of whatever.
-              // that we could handle using an object of pathname already seen but it will be useless
-              // because directoryPath is recursively traversed
-              followLink: false,
-            }),
-        })
+        collectOperation.throwIfAborted()
+        const directoryChildNodeStats = await readFileSystemNodeStat(
+          directoryChildNodeUrl,
+          {
+            // we ignore symlink because recursively traversed
+            // so symlinked file will be discovered.
+            // Moreover if they lead outside of directoryPath it can become a problem
+            // like infinite recursion of whatever.
+            // that we could handle using an object of pathname already seen but it will be useless
+            // because directoryPath is recursively traversed
+            followLink: false,
+          },
+        )
 
         if (directoryChildNodeStats.isDirectory()) {
           const subDirectoryUrl = `${directoryChildNodeUrl}/`
@@ -85,36 +80,30 @@ export const collectFiles = async ({
             directoryChildNodeUrl,
             rootDirectoryUrl,
           )
-          const operationResult = await createOperation({
-            cancellationToken,
-            start: () =>
-              matchingFileOperation({
-                cancellationToken,
-                relativeUrl,
-                meta,
-                fileStats: directoryChildNodeStats,
-              }),
-          })
           matchingFileResultArray.push({
             url: new URL(relativeUrl, rootDirectoryUrl).href,
             relativeUrl,
             meta,
             fileStats: directoryChildNodeStats,
-            operationResult,
           })
           return
         }
       }),
     )
   }
-  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
+  try {
+    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
+  } finally {
+    await collectOperation.end()
+  }
 }

package/src/copyDirectoryContent.js

@@ -1,3 +1,5 @@
+import { Abort } from "@jsenv/abort"
+
 import { assertAndNormalizeDirectoryUrl } from "./assertAndNormalizeDirectoryUrl.js"
 import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
@@ -5,11 +7,11 @@ import { readSymbolicLink } from "./readSymbolicLink.js"
 import { resolveUrl } from "./resolveUrl.js"
 import { readDirectory } from "./readDirectory.js"
 import { copyFileSystemNode } from "./copyFileSystemNode.js"
-
 import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js"
 import { statsToType } from "./internal/statsToType.js"
 
 export const copyDirectoryContent = async ({
+  signal = new AbortController().signal,
   from,
   to,
   overwrite,
@@ -65,17 +67,27 @@ export const copyDirectoryContent = async ({
     )
   }
 
-  const directoryEntries = await readDirectory(fromUrl)
-  await Promise.all(
-    directoryEntries.map(async (directoryEntry) => {
-      const from = resolveUrl(directoryEntry, fromUrl)
-      const to = resolveUrl(directoryEntry, toUrl)
-      await copyFileSystemNode({
-        from,
-        to,
-        overwrite,
-        followLink,
-      })
-    }),
-  )
+  const copyOperation = Abort.startOperation()
+  copyOperation.addAbortSignal(signal)
+  try {
+    copyOperation.throwIfAborted()
+    const directoryEntries = await readDirectory(fromUrl)
+    await Promise.all(
+      directoryEntries.map(async (directoryEntry) => {
+        const from = resolveUrl(directoryEntry, fromUrl)
+        const to = resolveUrl(directoryEntry, toUrl)
+        await copyOperation.withSignal(async (signal) => {
+          await copyFileSystemNode({
+            signal,
+            from,
+            to,
+            overwrite,
+            followLink,
+          })
+        })
+      }),
+    )
+  } finally {
+    await copyOperation.end()
+  }
 }

package/src/copyFileSystemNode.js

@@ -1,5 +1,5 @@
-/* eslint-disable import/max-dependencies */
 import { copyFile as copyFileNode } from "node:fs"
+import { Abort } from "@jsenv/abort"
 
 import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js"
 import { statsToType } from "./internal/statsToType.js"
@@ -21,6 +21,7 @@ import { removeFileSystemNode } from "./removeFileSystemNode.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 
 export const copyFileSystemNode = async ({
+  signal = new AbortController().signal,
   from,
   to,
   overwrite = false,
@@ -68,32 +69,15 @@ export const copyFileSystemNode = async ({
     )
   }
 
-  if (destinationStats) {
-    const sourceType = statsToType(sourceStats)
-    const destinationType = statsToType(destinationStats)
-
-    if (sourceType !== destinationType) {
-      throw new Error(
-        `cannot copy ${sourceType} from ${fromPath} to ${toPath} because destination exists and is not a ${sourceType} (it's a ${destinationType})`,
-      )
-    }
-    if (!overwrite) {
-      throw new Error(
-        `cannot copy ${sourceType} from ${fromPath} to ${toPath} because destination exists and overwrite option is disabled`,
-      )
-    }
-
-    // remove file, link, directory...
-    await removeFileSystemNode(toUrl, { recursive: true, allowUseless: true })
-  } else {
-    await ensureParentDirectories(toUrl)
-  }
-
   if (sourceStats.isDirectory()) {
     toUrl = ensureUrlTrailingSlash(toUrl)
   }
 
+  const copyOperation = Abort.startOperation()
+  copyOperation.addAbortSignal(signal)
+
   const visit = async (url, stats) => {
+    copyOperation.throwIfAborted()
     if (stats.isFile() || stats.isCharacterDevice() || stats.isBlockDevice()) {
       await visitFile(url, stats)
     } else if (stats.isSymbolicLink()) {
@@ -197,7 +181,37 @@ export const copyFileSystemNode = async ({
     )
   }
 
-  await visit(fromUrl, sourceStats)
+  try {
+    if (destinationStats) {
+      const sourceType = statsToType(sourceStats)
+      const destinationType = statsToType(destinationStats)
+
+      if (sourceType !== destinationType) {
+        throw new Error(
+          `cannot copy ${sourceType} from ${fromPath} to ${toPath} because destination exists and is not a ${sourceType} (it's a ${destinationType})`,
+        )
+      }
+      if (!overwrite) {
+        throw new Error(
+          `cannot copy ${sourceType} from ${fromPath} to ${toPath} because destination exists and overwrite option is disabled`,
+        )
+      }
+
+      // remove file, link, directory...
+      await removeFileSystemNode(toUrl, {
+        signal: copyOperation.signal,
+        recursive: true,
+        allowUseless: true,
+      })
+    } else {
+      await ensureParentDirectories(toUrl)
+    }
+
+    copyOperation.throwIfAborted()
+    await visit(fromUrl, sourceStats)
+  } finally {
+    await copyOperation.end()
+  }
 }
 
 const copyFileContentNaive = (filePath, fileDestinationPath) => {

package/src/listFilesMatching.js

@@ -1,31 +1,19 @@
 import { collectFiles } from "./collectFiles.js"
 
-export const listFilesMatching = async (
-  patterns,
+export const listFilesMatching = async ({
   directoryUrl = process.cwd(),
-) => {
-  if (typeof patterns === "string") {
-    patterns = [patterns]
-  } else if (Array.isArray(patterns)) {
-    throw new TypeError(
-      `patterns must be a string or an array of strings, got ${patterns}`,
-    )
+  patterns,
+  signal,
+}) => {
+  if (typeof patterns !== "object" || patterns === null) {
+    throw new TypeError(`patterns must be an object, got ${patterns}`)
   }
 
-  const patternMap = {}
-  patterns.forEach((pattern, index) => {
-    if (typeof pattern !== "string") {
-      throw new TypeError(
-        `every pattern must be a string, found ${pattern} at index ${index}`,
-      )
-    }
-    patternMap[pattern] = true
-  })
-
   const fileDatas = await collectFiles({
+    signal,
     directoryUrl,
     structuredMetaMap: {
-      matches: patternMap,
+      matches: patterns,
     },
     predicate: ({ matches }) => matches,
   })

package/src/moveDirectoryContent.js

@@ -1,3 +1,5 @@
+import { Abort } from "@jsenv/abort"
+
 import { assertAndNormalizeDirectoryUrl } from "./assertAndNormalizeDirectoryUrl.js"
 import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
 import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
@@ -5,11 +7,11 @@ import { readSymbolicLink } from "./readSymbolicLink.js"
 import { resolveUrl } from "./resolveUrl.js"
 import { readDirectory } from "./readDirectory.js"
 import { moveFileSystemNode } from "./moveFileSystemNode.js"
-
 import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js"
 import { statsToType } from "./internal/statsToType.js"
 
 export const moveDirectoryContent = async ({
+  signal = new AbortController().signal,
   from,
   to,
   overwrite,
@@ -65,17 +67,28 @@ export const moveDirectoryContent = async ({
     )
   }
 
-  const directoryEntries = await readDirectory(fromUrl)
-  await Promise.all(
-    directoryEntries.map(async (directoryEntry) => {
-      const from = resolveUrl(directoryEntry, fromUrl)
-      const to = resolveUrl(directoryEntry, toUrl)
-      await moveFileSystemNode({
-        from,
-        to,
-        overwrite,
-        followLink,
-      })
-    }),
-  )
+  const moveOperation = Abort.startOperation()
+  moveOperation.addAbortSignal(signal)
+  try {
+    moveOperation.throwIfAborted()
+    const directoryEntries = await readDirectory(fromUrl)
+    await Promise.all(
+      directoryEntries.map(async (directoryEntry) => {
+        const from = resolveUrl(directoryEntry, fromUrl)
+        const to = resolveUrl(directoryEntry, toUrl)
+
+        await moveOperation.withSignal(async (signal) => {
+          await moveFileSystemNode({
+            signal,
+            from,
+            to,
+            overwrite,
+            followLink,
+          })
+        })
+      }),
+    )
+  } finally {
+    await moveOperation.end()
+  }
 }

package/src/moveFileSystemNode.js

@@ -1,5 +1,5 @@
-/* eslint-disable import/max-dependencies */
 import { rename } from "node:fs"
+import { Abort } from "@jsenv/abort"
 
 import { urlTargetsSameFileSystemPath } from "./internal/urlTargetsSameFileSystemPath.js"
 import { statsToType } from "./internal/statsToType.js"
@@ -13,6 +13,7 @@ import { readFileSystemNodeStat } from "./readFileSystemNodeStat.js"
 import { readSymbolicLink } from "./readSymbolicLink.js"
 
 export const moveFileSystemNode = async ({
+  signal = new AbortController().signal,
   from,
   to,
   overwrite = false,
@@ -57,37 +58,51 @@ export const moveFileSystemNode = async ({
     )
   }
 
-  if (destinationStats) {
-    const sourceType = statsToType(sourceStats)
-    const destinationType = statsToType(destinationStats)
+  const moveOperation = Abort.startOperation()
+  moveOperation.addAbortSignal(signal)
 
-    if (sourceType !== destinationType) {
-      throw new Error(
-        `cannot move ${sourceType} from ${fromPath} to ${toPath} because destination exists and is not a ${sourceType} (it's a ${destinationType})`,
-      )
-    }
-    if (!overwrite) {
-      throw new Error(
-        `cannot move ${sourceType} from ${fromPath} to ${toPath} because destination exists and overwrite option is disabled`,
-      )
-    }
+  try {
+    if (destinationStats) {
+      const sourceType = statsToType(sourceStats)
+      const destinationType = statsToType(destinationStats)
 
-    // remove file, link, directory...
-    await removeFileSystemNode(toUrl, { recursive: true })
-  } else {
-    await ensureParentDirectories(toUrl)
-  }
+      if (sourceType !== destinationType) {
+        throw new Error(
+          `cannot move ${sourceType} from ${fromPath} to ${toPath} because destination exists and is not a ${sourceType} (it's a ${destinationType})`,
+        )
+      }
+      if (!overwrite) {
+        throw new Error(
+          `cannot move ${sourceType} from ${fromPath} to ${toPath} because destination exists and overwrite option is disabled`,
+        )
+      }
 
-  await moveNaive(fromPath, toPath, {
-    handleCrossDeviceError: async () => {
-      await copyFileSystemNode({
-        from: fromUrl,
-        to: toUrl,
-        preserveStat: true,
+      // remove file, link, directory...
+      await removeFileSystemNode(toUrl, {
+        signal: moveOperation.signal,
+        recursive: true,
       })
-      await removeFileSystemNode(fromUrl, { recursive: true })
-    },
-  })
+    } else {
+      await ensureParentDirectories(toUrl)
+    }
+
+    moveOperation.throwIfAborted()
+    await moveNaive(fromPath, toPath, {
+      handleCrossDeviceError: async () => {
+        await copyFileSystemNode({
+          from: fromUrl,
+          to: toUrl,
+          preserveStat: true,
+        })
+        await removeFileSystemNode(fromUrl, {
+          signal: moveOperation.signal,
+          recursive: true,
+        })
+      },
+    })
+  } finally {
+    await moveOperation.end()
+  }
 }
 
 const moveNaive = (