@magic/fs 0.0.37 → 0.0.39

package/README.md

@@ -338,7 +338,12 @@ update dependencies
 
 - update dependencies
 
-##### 0.0.38 - unreleased
+##### 0.0.38
+
+- update types
+- update dependencies
+
+##### 0.0.39 - unreleased
 
 ...
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic/fs",
-  "version": "0.0.37",
+  "version": "0.0.39",
   "author": "Wizards & Witches",
   "description": "nodejs fs promises + goodies",
   "license": "AGPL-3.0",
@@ -21,10 +21,12 @@
     "prod": "NODE_ENV=production magic build serve",
     "clean": "magic clean",
     "serve": "magic serve",
-    "dev": "magic dev"
+    "dev": "magic dev",
+    "tsc": "tsc --noEmit",
+    "check": "npm run tsc"
   },
   "engines": {
-    "node": ">=14.15.4"
+    "node": ">=20.0.0"
   },
   "engineStrict": true,
   "repository": {
@@ -40,18 +42,18 @@
     "@magic-modules/no-spy": "0.0.9",
     "@magic-modules/pre": "0.0.12",
     "@magic-themes/docs": "0.0.15",
-    "@magic/core": "0.0.156",
-    "@magic/format": "0.0.68",
-    "@magic/test": "0.2.25",
-    "@types/node": "24.9.2",
-    "typescript": "5.9.3"
+    "@magic/core": "0.0.158",
+    "@magic/format": "0.0.74",
+    "@magic/test": "0.3.19",
+    "@types/node": "26.0.1",
+    "typescript": "6.0.3"
   },
   "dependencies": {
-    "@magic/deep": "0.1.20",
-    "@magic/error": "0.0.21",
-    "@magic/log": "0.1.21",
-    "@magic/mime-types": "0.0.22",
-    "@magic/types": "0.1.30"
+    "@magic/deep": "0.1.21",
+    "@magic/error": "0.0.23",
+    "@magic/log": "0.1.22",
+    "@magic/mime-types": "0.0.23",
+    "@magic/types": "0.1.37"
   },
   "files": [
     "src",

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
@@ -49,9 +49,11 @@ export const fs: {
   readonly fchmod: typeof fso.fchmod
   readonly fchmodSync: typeof fso.fchmodSync
   readonly lchmodSync: typeof fso.lchmodSync
+  readonly statSync: typeof fso.statSync
   readonly fstat: typeof fso.fstat
   readonly fstatSync: typeof fso.fstatSync
   readonly statfsSync: typeof fso.statfsSync
+  readonly lstatSync: typeof fso.lstatSync
   readonly linkSync: typeof fso.linkSync
   readonly symlinkSync: typeof fso.symlinkSync
   readonly readlinkSync: typeof fso.readlinkSync
@@ -95,7 +97,6 @@ export const fs: {
   readonly opendirSync: typeof fso.opendirSync
   readonly cpSync: typeof fso.cpSync
   readonly globSync: typeof fso.globSync
-  readonly promises: typeof fso.promises
   readonly Stats: typeof fso.Stats
   readonly StatsFs: typeof fso.StatsFs
   readonly Dirent: typeof fso.Dirent
@@ -103,7 +104,6 @@ export const fs: {
   readonly ReadStream: typeof fso.ReadStream
   readonly Utf8Stream: typeof fso.Utf8Stream
   readonly WriteStream: typeof fso.WriteStream
-  readonly statSync: fso.StatSyncFn
-  readonly lstatSync: fso.StatSyncFn
+  readonly promises: typeof fso.promises
 }
 import fso from 'node:fs'

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?: {
@@ -33,7 +36,7 @@ export const fs: {
           root?: string
         },
   ) => Promise<string[]>
-  readonly exists: (f: import('fs').PathLike) => Promise<boolean>
+  readonly exists: (f: import('node:fs').PathLike) => Promise<boolean>
   readonly getContentType: (uri: string) => string
   readonly getFilePath: (
     fn:
@@ -76,110 +79,110 @@ export const fs: {
           root?: string
         },
   ) => Promise<string | string[] | undefined>
-  readonly readdir: typeof import('fs/promises').readdir
-  readonly readDir: typeof import('fs/promises').readdir
-  readonly readFile: typeof import('fs/promises').readFile
-  readonly readfile: typeof import('fs/promises').readFile
-  readonly rmdir: typeof import('fs/promises').rmdir
-  readonly rmDir: typeof import('fs/promises').rmdir
-  readonly watch: typeof import('fs').watch
-  readonly access: typeof import('fs/promises').access
-  readonly copyFile: typeof import('fs/promises').copyFile
-  readonly open: typeof import('fs/promises').open
-  readonly rename: typeof import('fs/promises').rename
-  readonly truncate: typeof import('fs/promises').truncate
-  readonly rm: typeof import('fs/promises').rm
-  readonly mkdir: typeof import('fs/promises').mkdir
-  readonly readlink: typeof import('fs/promises').readlink
-  readonly symlink: typeof import('fs/promises').symlink
-  readonly lstat: typeof import('fs/promises').lstat
-  readonly stat: typeof import('fs/promises').stat
-  readonly statfs: typeof import('fs/promises').statfs
-  readonly link: typeof import('fs/promises').link
-  readonly unlink: typeof import('fs/promises').unlink
-  readonly chmod: typeof import('fs/promises').chmod
-  readonly lchmod: typeof import('fs/promises').lchmod
-  readonly lchown: typeof import('fs/promises').lchown
-  readonly lutimes: typeof import('fs/promises').lutimes
-  readonly chown: typeof import('fs/promises').chown
-  readonly utimes: typeof import('fs/promises').utimes
-  readonly realpath: typeof import('fs/promises').realpath
-  readonly mkdtemp: typeof import('fs/promises').mkdtemp
-  readonly mkdtempDisposable: typeof import('fs/promises').mkdtempDisposable
-  readonly writeFile: typeof import('fs/promises').writeFile
-  readonly appendFile: typeof import('fs/promises').appendFile
-  readonly opendir: typeof import('fs/promises').opendir
-  readonly cp: typeof import('fs/promises').cp
-  readonly glob: typeof import('fs/promises').glob
-  readonly constants: typeof import('fs').constants
-  readonly renameSync: typeof import('fs').renameSync
-  readonly truncateSync: typeof import('fs').truncateSync
-  readonly ftruncate: typeof import('fs').ftruncate
-  readonly ftruncateSync: typeof import('fs').ftruncateSync
-  readonly chownSync: typeof import('fs').chownSync
-  readonly fchown: typeof import('fs').fchown
-  readonly fchownSync: typeof import('fs').fchownSync
-  readonly lchownSync: typeof import('fs').lchownSync
-  readonly lutimesSync: typeof import('fs').lutimesSync
-  readonly chmodSync: typeof import('fs').chmodSync
-  readonly fchmod: typeof import('fs').fchmod
-  readonly fchmodSync: typeof import('fs').fchmodSync
-  readonly lchmodSync: typeof import('fs').lchmodSync
-  readonly fstat: typeof import('fs').fstat
-  readonly fstatSync: typeof import('fs').fstatSync
-  readonly statfsSync: typeof import('fs').statfsSync
-  readonly linkSync: typeof import('fs').linkSync
-  readonly symlinkSync: typeof import('fs').symlinkSync
-  readonly readlinkSync: typeof import('fs').readlinkSync
-  readonly realpathSync: typeof import('fs').realpathSync
-  readonly unlinkSync: typeof import('fs').unlinkSync
-  readonly rmdirSync: typeof import('fs').rmdirSync
-  readonly rmSync: typeof import('fs').rmSync
-  readonly mkdirSync: typeof import('fs').mkdirSync
-  readonly mkdtempSync: typeof import('fs').mkdtempSync
-  readonly mkdtempDisposableSync: typeof import('fs').mkdtempDisposableSync
-  readonly readdirSync: typeof import('fs').readdirSync
-  readonly close: typeof import('fs').close
-  readonly closeSync: typeof import('fs').closeSync
-  readonly openSync: typeof import('fs').openSync
-  readonly utimesSync: typeof import('fs').utimesSync
-  readonly futimes: typeof import('fs').futimes
-  readonly futimesSync: typeof import('fs').futimesSync
-  readonly fsync: typeof import('fs').fsync
-  readonly fsyncSync: typeof import('fs').fsyncSync
-  readonly write: typeof import('fs').write
-  readonly writeSync: typeof import('fs').writeSync
-  readonly read: typeof import('fs').read
-  readonly readSync: typeof import('fs').readSync
-  readonly readFileSync: typeof import('fs').readFileSync
-  readonly writeFileSync: typeof import('fs').writeFileSync
-  readonly appendFileSync: typeof import('fs').appendFileSync
-  readonly watchFile: typeof import('fs').watchFile
-  readonly unwatchFile: typeof import('fs').unwatchFile
-  readonly existsSync: typeof import('fs').existsSync
-  readonly accessSync: typeof import('fs').accessSync
-  readonly createReadStream: typeof import('fs').createReadStream
-  readonly createWriteStream: typeof import('fs').createWriteStream
-  readonly fdatasync: typeof import('fs').fdatasync
-  readonly fdatasyncSync: typeof import('fs').fdatasyncSync
-  readonly copyFileSync: typeof import('fs').copyFileSync
-  readonly writev: typeof import('fs').writev
-  readonly writevSync: typeof import('fs').writevSync
-  readonly readv: typeof import('fs').readv
-  readonly readvSync: typeof import('fs').readvSync
-  readonly openAsBlob: typeof import('fs').openAsBlob
-  readonly opendirSync: typeof import('fs').opendirSync
-  readonly cpSync: typeof import('fs').cpSync
-  readonly globSync: typeof import('fs').globSync
+  readonly readdir: typeof import('node:fs/promises').readdir
+  readonly readDir: typeof import('node:fs/promises').readdir
+  readonly readFile: typeof import('node:fs/promises').readFile
+  readonly readfile: typeof import('node:fs/promises').readFile
+  readonly rmdir: typeof import('node:fs/promises').rmdir
+  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
+  readonly truncate: typeof import('node:fs/promises').truncate
+  readonly rm: typeof import('node:fs/promises').rm
+  readonly mkdir: typeof import('node:fs/promises').mkdir
+  readonly readlink: typeof import('node:fs/promises').readlink
+  readonly symlink: typeof import('node:fs/promises').symlink
+  readonly lstat: typeof import('node:fs/promises').lstat
+  readonly stat: typeof import('node:fs/promises').stat
+  readonly statfs: typeof import('node:fs/promises').statfs
+  readonly link: typeof import('node:fs/promises').link
+  readonly unlink: typeof import('node:fs/promises').unlink
+  readonly chmod: typeof import('node:fs/promises').chmod
+  readonly lchmod: typeof import('node:fs/promises').lchmod
+  readonly lchown: typeof import('node:fs/promises').lchown
+  readonly lutimes: typeof import('node:fs/promises').lutimes
+  readonly chown: typeof import('node:fs/promises').chown
+  readonly utimes: typeof import('node:fs/promises').utimes
+  readonly realpath: typeof import('node:fs/promises').realpath
+  readonly mkdtemp: typeof import('node:fs/promises').mkdtemp
+  readonly mkdtempDisposable: typeof import('node:fs/promises').mkdtempDisposable
+  readonly writeFile: typeof import('node:fs/promises').writeFile
+  readonly appendFile: typeof import('node:fs/promises').appendFile
+  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 renameSync: typeof import('node:fs').renameSync
+  readonly truncateSync: typeof import('node:fs').truncateSync
+  readonly ftruncate: typeof import('node:fs').ftruncate
+  readonly ftruncateSync: typeof import('node:fs').ftruncateSync
+  readonly chownSync: typeof import('node:fs').chownSync
+  readonly fchown: typeof import('node:fs').fchown
+  readonly fchownSync: typeof import('node:fs').fchownSync
+  readonly lchownSync: typeof import('node:fs').lchownSync
+  readonly lutimesSync: typeof import('node:fs').lutimesSync
+  readonly chmodSync: typeof import('node:fs').chmodSync
+  readonly fchmod: typeof import('node:fs').fchmod
+  readonly fchmodSync: typeof import('node:fs').fchmodSync
+  readonly lchmodSync: typeof import('node:fs').lchmodSync
+  readonly statSync: typeof import('node:fs').statSync
+  readonly fstat: typeof import('node:fs').fstat
+  readonly fstatSync: typeof import('node:fs').fstatSync
+  readonly statfsSync: typeof import('node:fs').statfsSync
+  readonly lstatSync: typeof import('node:fs').lstatSync
+  readonly linkSync: typeof import('node:fs').linkSync
+  readonly symlinkSync: typeof import('node:fs').symlinkSync
+  readonly readlinkSync: typeof import('node:fs').readlinkSync
+  readonly realpathSync: typeof import('node:fs').realpathSync
+  readonly unlinkSync: typeof import('node:fs').unlinkSync
+  readonly rmdirSync: typeof import('node:fs').rmdirSync
+  readonly rmSync: typeof import('node:fs').rmSync
+  readonly mkdirSync: typeof import('node:fs').mkdirSync
+  readonly mkdtempSync: typeof import('node:fs').mkdtempSync
+  readonly mkdtempDisposableSync: typeof import('node:fs').mkdtempDisposableSync
+  readonly readdirSync: typeof import('node:fs').readdirSync
+  readonly close: typeof import('node:fs').close
+  readonly closeSync: typeof import('node:fs').closeSync
+  readonly openSync: typeof import('node:fs').openSync
+  readonly utimesSync: typeof import('node:fs').utimesSync
+  readonly futimes: typeof import('node:fs').futimes
+  readonly futimesSync: typeof import('node:fs').futimesSync
+  readonly fsync: typeof import('node:fs').fsync
+  readonly fsyncSync: typeof import('node:fs').fsyncSync
+  readonly write: typeof import('node:fs').write
+  readonly writeSync: typeof import('node:fs').writeSync
+  readonly read: typeof import('node:fs').read
+  readonly readSync: typeof import('node:fs').readSync
+  readonly readFileSync: typeof import('node:fs').readFileSync
+  readonly writeFileSync: typeof import('node:fs').writeFileSync
+  readonly appendFileSync: typeof import('node:fs').appendFileSync
+  readonly watchFile: typeof import('node:fs').watchFile
+  readonly unwatchFile: typeof import('node:fs').unwatchFile
+  readonly existsSync: typeof import('node:fs').existsSync
+  readonly accessSync: typeof import('node:fs').accessSync
+  readonly createReadStream: typeof import('node:fs').createReadStream
+  readonly createWriteStream: typeof import('node:fs').createWriteStream
+  readonly fdatasync: typeof import('node:fs').fdatasync
+  readonly fdatasyncSync: typeof import('node:fs').fdatasyncSync
+  readonly copyFileSync: typeof import('node:fs').copyFileSync
+  readonly writev: typeof import('node:fs').writev
+  readonly writevSync: typeof import('node:fs').writevSync
+  readonly readv: typeof import('node:fs').readv
+  readonly readvSync: typeof import('node:fs').readvSync
+  readonly openAsBlob: typeof import('node:fs').openAsBlob
+  readonly opendirSync: typeof import('node:fs').opendirSync
+  readonly cpSync: typeof import('node:fs').cpSync
+  readonly globSync: typeof import('node:fs').globSync
+  readonly Stats: typeof import('node:fs').Stats
+  readonly StatsFs: typeof import('node:fs').StatsFs
+  readonly Dirent: typeof import('node:fs').Dirent
+  readonly Dir: typeof import('node:fs').Dir
+  readonly ReadStream: typeof import('node:fs').ReadStream
+  readonly Utf8Stream: typeof import('node:fs').Utf8Stream
+  readonly WriteStream: typeof import('node:fs').WriteStream
   readonly promises: typeof import('node:fs/promises')
-  readonly Stats: typeof import('fs').Stats
-  readonly StatsFs: typeof import('fs').StatsFs
-  readonly Dirent: typeof import('fs').Dirent
-  readonly Dir: typeof import('fs').Dir
-  readonly ReadStream: typeof import('fs').ReadStream
-  readonly Utf8Stream: typeof import('fs').Utf8Stream
-  readonly WriteStream: typeof import('fs').WriteStream
-  readonly statSync: import('fs').StatSyncFn
-  readonly lstatSync: import('fs').StatSyncFn
 }
 export default fs

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>