@magic/fs 0.0.38 → 0.0.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic/fs",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "author": "Wizards & Witches",
   "description": "nodejs fs promises + goodies",
   "license": "AGPL-3.0",
@@ -26,7 +26,7 @@
     "check": "npm run tsc"
   },
   "engines": {
-    "node": ">=14.15.4"
+    "node": ">=20.0.0"
   },
   "engineStrict": true,
   "repository": {
@@ -43,9 +43,9 @@
     "@magic-modules/pre": "0.0.12",
     "@magic-themes/docs": "0.0.15",
     "@magic/core": "0.0.158",
-    "@magic/format": "0.0.73",
-    "@magic/test": "0.3.12",
-    "@types/node": "25.9.2",
+    "@magic/format": "0.0.74",
+    "@magic/test": "0.3.19",
+    "@types/node": "26.0.1",
     "typescript": "6.0.3"
   },
   "dependencies": {

package/src/exists.js

@@ -1,4 +1,5 @@
 import { fs } from './fs.js'
+import { constants } from 'node:fs'
 
 import error from '@magic/error'
 import is from '@magic/types'
@@ -16,7 +17,7 @@ export const exists = async f => {
   }
 
   try {
-    await fs.stat(f)
+    await fs.access(f, constants.F_OK)
     return true
   } catch (e) {
     const err = /** @type {Error & { code: string }} */ (e)

package/src/fs.js

@@ -1,19 +1,24 @@
-import fso from 'node:fs'
-import util from 'node:util'
-
-const readDir = fso.promises.readdir
-const readFile = fso.promises.readFile
-const rmdir = fso.promises.rmdir
+import fso, { constants } from 'node:fs'
+import { access } from 'node:fs/promises'
 
 export const fs = /** @type {const} */ ({
   ...fso,
   ...fso.promises,
-  exists: util.promisify(fso.exists),
-  readdir: readDir,
-  readDir,
-  readFile,
-  readfile: readFile,
-  rmdir,
-  rmDir: rmdir,
+  exists: async (/** @type {import('node:fs').PathLike} */ f) => {
+    try {
+      await access(f, constants.F_OK)
+      return true
+    } catch {
+      return false
+    }
+  },
+  readdir: fso.promises.readdir,
+  readDir: fso.promises.readdir,
+  readFile: fso.promises.readFile,
+  readfile: fso.promises.readFile,
+  rmdir: fso.promises.rmdir,
+  rmDir: fso.promises.rmdir,
   watch: fso.watch,
+  access,
+  constants,
 })

package/src/getDirectories.js

@@ -6,8 +6,6 @@ import error from '@magic/error'
 
 import { fs } from './fs.js'
 
-import { getFilePath } from './getFilePath.js'
-
 const libName = '@magic/fs.getDirectories'
 
 /**
@@ -28,10 +26,17 @@ export const getDirectories = async (dir, options = {}) => {
     }
   }
 
-  let { minDepth, maxDepth = false, depth = false, root, noRoot = false } = options
+  let { minDepth, maxDepth = false, depth, root, noRoot = false } = options
+
+  // Only apply depth === false logic if explicitly passed, not if undefined
+  const depthExplicitlyFalse = 'depth' in options && depth === false
 
   if (!is.number(maxDepth)) {
-    maxDepth = is.number(depth) ? depth : 200_000
+    if (depthExplicitlyFalse) {
+      maxDepth = 1
+    } else {
+      maxDepth = is.number(depth) ? depth : 200_000
+    }
   }
 
   if (!is.number(minDepth)) {
@@ -56,68 +61,44 @@ export const getDirectories = async (dir, options = {}) => {
 
   try {
     if (is.array(dir)) {
-      const dirs = await Promise.all(dir.map(async f => await getDirectories(f, options)))
+      const dirs = await Promise.all(dir.map(f => getDirectories(f, options)))
 
       return deep.flatten(...dirs).filter(a => a)
     }
 
-    const currentDepth = dir
-      .replace(root || process.cwd(), '')
-      .split(path.sep)
-      .filter(a => a).length
-
-    if (currentDepth > maxDepth) {
-      return []
-    }
-
-    const dirContent = await fs.readdir(dir)
+    // Use recursive readdir with file types - single syscall, no per-file stat needed
+    const entries = await fs.readdir(dir, { recursive: true, withFileTypes: true })
 
     /** @type {string[]} */
     const dirs = []
 
-    await Promise.all(
-      dirContent.map(async file => {
-        if (!is.string(file)) {
-          throw error(`${libName}: path was not a string: ${file}`, 'E_ARG_TYPE')
-        }
+    if (!noRoot) {
+      // Root dir is depth 0
+      if (0 >= minDepth && 0 <= maxDepth) {
+        dirs.push(dir)
+      }
+    }
 
-        let filePath = await getFilePath(getDirectories, dir, file, { maxDepth, minDepth, root })
-
-        if (filePath) {
-          if (!is.array(filePath)) {
-            filePath = [filePath]
-          }
-
-          await Promise.all(
-            filePath.map(async file => {
-              try {
-                const stat = await fs.stat(file)
-                if (stat.isDirectory()) {
-                  if (is.array(filePath)) {
-                    dirs.push(...filePath)
-                  } else if (is.string(filePath)) {
-                    dirs.push(filePath)
-                  }
-                }
-              } catch (statErr) {
-                // File might have been deleted between readdir and stat
-                // Just skip it
-              }
-            }),
-          )
-        }
-      }),
-    )
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        // Use parentPath + name for correct full path with recursive readdir
+        const fullPath = path.join(entry.parentPath, entry.name)
 
-    let finalDirs = deep.flatten(dirs).filter(a => a)
-    if (!noRoot) {
-      finalDirs = [dir, ...finalDirs]
+        // Calculate depth relative to root
+        const relativePath = path.relative(root || dir, fullPath)
+        const entryDepth = relativePath.split(path.sep).filter(Boolean).length
+
+        // Filter by minDepth and maxDepth
+        if (entryDepth >= minDepth && entryDepth <= maxDepth) {
+          dirs.push(fullPath)
+        }
+      }
     }
 
-    const finalized = finalDirs
+    const finalized = dirs
       .filter(a => is.string(a))
-      .filter(dir => {
-        const currentDepth = dir
+      .filter(d => {
+        const currentDepth = d
           .replace(root || process.cwd(), '')
           .split(path.sep)
           .filter(a => a).length

package/src/getFilePath.js

@@ -39,10 +39,17 @@ export const getFilePath = async (fn, dir, file, args = {}) => {
 
   const filePath = path.join(dir, file)
 
-  const stat = await fs.stat(filePath)
-  if (stat.isDirectory()) {
+  // Use readdir with withFileTypes - more efficient than stat
+  const entries = await fs.readdir(dir, { withFileTypes: true })
+  const entry = entries.find(e => e.name === file)
+
+  if (!entry) {
+    return undefined
+  }
+
+  if (entry.isDirectory()) {
     return await fn(filePath, args)
-  } else if (stat.isFile()) {
+  } else if (entry.isFile()) {
     return filePath
   }
 }

package/src/getFiles.js

@@ -1,10 +1,8 @@
 import path from 'node:path'
 
-// import deep from '@magic/deep'
 import is from '@magic/types'
 import error from '@magic/error'
 
-import { getFilePath } from './getFilePath.js'
 import { fs } from './fs.js'
 
 const libName = '@magic/fs.getFiles'
@@ -54,60 +52,42 @@ export const getFiles = async (dir, options = {}) => {
     root = dir
   }
 
-  const currentDepth = dir
-    .replace(root, '')
-    .split(path.sep)
-    .filter(a => a).length
-
-  if (currentDepth > maxDepth) {
-    return []
-  }
-
   try {
-    const dirContent = await fs.readdir(dir)
-    const files = await Promise.all(
-      dirContent.map(file => getFilePath(getFiles, dir, file, { maxDepth, minDepth, root })),
-    )
-
-    const flatFiles = files
-      .flat(20000)
-      .filter(a => !is.undef(a))
-      /*
-       * if an extension parameter has been passed,
-       * remove the file if it does not end with extension
-       */
-      .filter(a => !extension || a.endsWith(extension))
-
-    /*
-     * filter nonfiles - use async stat
-     */
-    const fileStats = await Promise.all(
-      flatFiles.map(async f => {
-        try {
-          const stat = await fs.stat(f)
-          return { path: f, isFile: stat.isFile() }
-        } catch {
-          return { path: f, isFile: false }
-        }
-      }),
-    )
+    // Use recursive readdir with file types - single syscall, no per-file stat needed
+    const entries = await fs.readdir(dir, { recursive: true, withFileTypes: true })
 
     return (
-      fileStats
-        .filter(({ isFile }) => isFile)
-        .map(({ path }) => path)
-        /*
-         * filter files if depth is smaller than minDepth
-         */
-        .filter(file => {
-          const currentDepth =
-            file
-              .replace(root ?? '', '')
-              .split(path.sep)
-              .filter(a => a).length - 1
-
-          return currentDepth >= minDepth
+      entries
+        .filter(entry => {
+          // Only files
+          if (!entry.isFile()) {
+            return false
+          }
+
+          // Calculate depth relative to root - based on parent directory, not file name
+          const parentPath = path.join(entry.parentPath)
+          const relativePath = path.relative(root, parentPath)
+          const entryDepth = relativePath.split(path.sep).filter(Boolean).length
+
+          // Filter by maxDepth
+          if (entryDepth > maxDepth) {
+            return false
+          }
+
+          // Filter by minDepth
+          if (entryDepth < minDepth) {
+            return false
+          }
+
+          // Filter by extension
+          if (extension && !relativePath.endsWith(extension)) {
+            return false
+          }
+
+          return true
         })
+        // Use parentPath + name for correct full path with recursive readdir
+        .map(entry => path.join(entry.parentPath, entry.name))
     )
   } catch (e) {
     const err = /** @type {Error & { code?: string }} */ (e)

package/src/mkdirp.js

@@ -1,18 +1,17 @@
-import path from 'path'
-
-import error from '@magic/error'
 import is from '@magic/types'
-
 import { fs } from './fs.js'
+import error from '@magic/error'
 
 const libName = '@magic/fs.mkdirp'
 
 /**
  *
- * @param {string} p
- * @returns {Promise<boolean | void>}
+ * @param {import('node:fs').PathLike} p
+ * @param {import('node:fs').MakeDirectoryOptions} opts
+ *
+ * @returns {Promise<boolean>}
  */
-export const mkdirp = async p => {
+export const mkdirp = async (p, opts = {}) => {
   if (is.empty(p)) {
     throw error(`${libName} expects a non-empty path string as argument.`, 'E_ARG_EMPTY')
   }
@@ -21,17 +20,8 @@ export const mkdirp = async p => {
     throw error(`${libName} expects a path string as argument, got: ${typeof p}`, 'E_ARG_TYPE')
   }
 
-  p = path.resolve(p)
-
   try {
-    const dir = path.dirname(p)
-    let exists = await fs.exists(dir)
-
-    if (!exists) {
-      await mkdirp(dir)
-    }
-
-    await fs.mkdir(p)
+    await fs.mkdir(p, { ...opts, recursive: true })
     return true
   } catch (e) {
     const err = /** @type {Error & { code?: string}} */ (e)

package/src/rmrf.js

@@ -1,4 +1,4 @@
-import path from 'path'
+import path from 'node:path'
 
 import is from '@magic/types'
 import error from '@magic/error'
@@ -36,23 +36,10 @@ export const rmrf = async (dir, opts = {}) => {
   }
 
   try {
-    const stat = await fs.stat(dir)
-
-    if (stat.isFile()) {
-      if (!opts.dryRun) {
-        await fs.unlink(dir)
-      }
-      return true
-    } else if (stat.isDirectory()) {
-      const files = await fs.readdir(dir)
-
-      await Promise.all(files.map(async file => await rmrf(path.join(dir, file))))
-
-      if (!opts.dryRun) {
-        await fs.rmdir(dir)
-      }
-      return true
+    if (!opts.dryRun) {
+      await fs.rm(dir, { recursive: true, force: true })
     }
+    return true
   } catch (e) {
     const err = /** @type {Error & { code?: string}} */ (e)
 

package/types/fs.d.ts

@@ -1,5 +1,5 @@
 export const fs: {
-  readonly exists: typeof fso.exists.__promisify__
+  readonly exists: (f: import('node:fs').PathLike) => Promise<boolean>
   readonly readdir: typeof fso.promises.readdir
   readonly readDir: typeof fso.promises.readdir
   readonly readFile: typeof fso.promises.readFile
@@ -8,6 +8,7 @@ export const fs: {
   readonly rmDir: typeof fso.promises.rmdir
   readonly watch: typeof fso.watch
   readonly access: typeof fso.promises.access
+  readonly constants: typeof fso.constants
   readonly copyFile: typeof fso.promises.copyFile
   readonly open: typeof fso.promises.open
   readonly rename: typeof fso.promises.rename
@@ -35,7 +36,6 @@ export const fs: {
   readonly opendir: typeof fso.promises.opendir
   readonly cp: typeof fso.promises.cp
   readonly glob: typeof fso.promises.glob
-  readonly constants: typeof fso.constants
   readonly renameSync: typeof fso.renameSync
   readonly truncateSync: typeof fso.truncateSync
   readonly ftruncate: typeof fso.ftruncate

package/types/index.d.ts

@@ -1,5 +1,8 @@
 export const fs: {
-  readonly mkdirp: (p: string) => Promise<boolean | void>
+  readonly mkdirp: (
+    p: import('node:fs').PathLike,
+    opts?: import('node:fs').MakeDirectoryOptions,
+  ) => Promise<boolean>
   readonly rmrf: (
     dir: string,
     opts?: {
@@ -84,6 +87,7 @@ export const fs: {
   readonly rmDir: typeof import('node:fs/promises').rmdir
   readonly watch: typeof import('node:fs').watch
   readonly access: typeof import('node:fs/promises').access
+  readonly constants: typeof import('node:fs').constants
   readonly copyFile: typeof import('node:fs/promises').copyFile
   readonly open: typeof import('node:fs/promises').open
   readonly rename: typeof import('node:fs/promises').rename
@@ -111,7 +115,6 @@ export const fs: {
   readonly opendir: typeof import('node:fs/promises').opendir
   readonly cp: typeof import('node:fs/promises').cp
   readonly glob: typeof import('node:fs/promises').glob
-  readonly constants: typeof import('node:fs').constants
   readonly renameSync: typeof import('node:fs').renameSync
   readonly truncateSync: typeof import('node:fs').truncateSync
   readonly ftruncate: typeof import('node:fs').ftruncate

package/types/mkdirp.d.ts

@@ -1 +1,4 @@
-export function mkdirp(p: string): Promise<boolean | void>
+export function mkdirp(
+  p: import('node:fs').PathLike,
+  opts?: import('node:fs').MakeDirectoryOptions,
+): Promise<boolean>