@magic/fs 0.0.31 → 0.0.32

package/README.md

@@ -72,9 +72,9 @@ rmDir
 ### export overloads:
 
 ```javascript
-rmdir, rmDir
-readfile, readFile
-readdir, readDir
+// rmdir, rmDir
+// readfile, readFile
+// readdir, readDir
 ```
 
 ### Additional functions:
@@ -312,7 +312,12 @@ update dependencies
 - add tests for [...threedot_dirs]
 - update dependencies
 
-##### 0.0.32 - unreleased
+##### 0.0.32
+
+- add jsdoc types
+- update dependencies
+
+##### 0.0.33 - unreleased
 
 ...
 

package/package.json

@@ -1,20 +1,23 @@
 {
   "name": "@magic/fs",
-  "version": "0.0.31",
+  "version": "0.0.32",
   "author": "Wizards & Witches",
   "description": "nodejs fs promises + goodies",
   "license": "AGPL-3.0",
   "homepage": "https://magic.github.io/fs",
   "main": "src/index.mjs",
+  "types": "types/index.d.ts",
   "module": "src/index.mjs",
   "type": "module",
   "scripts": {
     "start": "npm test",
+    "build": "tsc && npm run format",
+    "prepublishOnly": "npm run test && npm run build",
     "test": "t --exclude docs example config.js",
     "format": "f -w --exclude docs",
     "format:check": "f",
     "calls": "calls",
-    "build": "NODE_ENV=production magic build",
+    "build:docs": "NODE_ENV=production magic build",
     "prod": "NODE_ENV=production magic build serve",
     "clean": "magic clean",
     "serve": "magic serve",
@@ -38,18 +41,21 @@
     "@magic-modules/pre": "0.0.12",
     "@magic-themes/docs": "0.0.15",
     "@magic/core": "0.0.156",
-    "@magic/format": "0.0.66",
-    "@magic/test": "0.2.20"
+    "@magic/format": "0.0.68",
+    "@magic/test": "0.2.22",
+    "@types/node": "24.7.2",
+    "typescript": "5.9.3"
   },
   "dependencies": {
-    "@magic/deep": "0.1.16",
-    "@magic/error": "0.0.17",
-    "@magic/log": "0.1.18",
-    "@magic/mime-types": "0.0.18",
-    "@magic/types": "0.1.23"
+    "@magic/deep": "0.1.18",
+    "@magic/error": "0.0.20",
+    "@magic/log": "0.1.20",
+    "@magic/mime-types": "0.0.21",
+    "@magic/types": "0.1.29"
   },
   "files": [
-    "src"
+    "src",
+    "types"
   ],
   "contributors": [
     {

package/src/{exists.mjs → exists.js}

@@ -1,10 +1,11 @@
-import { fs } from './fs.mjs'
+import { fs } from './fs.js'
 
 import error from '@magic/error'
 import is from '@magic/types'
 
 const libName = '@magic/fs.exists'
 
+/** @type {(f: import('node:fs').PathLike) => Promise<boolean>} */
 export const exists = async f => {
   if (is.empty(f)) {
     throw error(`${libName} expects argument to be non-empty`, 'E_ARG_EMPTY')
@@ -18,10 +19,11 @@ export const exists = async f => {
     await fs.stat(f)
     return true
   } catch (e) {
-    if (e.code === 'ENOENT') {
+    const err = /** @type {Error & { code: string }} */ (e)
+    if (err.code === 'ENOENT') {
       return false
     }
 
-    throw error(e.message, e.code || e.name)
+    throw error(err.message, err.code || err.name)
   }
 }

package/src/{fs.mjs → fs.js}

@@ -1,11 +1,11 @@
-import fso from 'fs'
-import util from 'util'
+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
 
-export const fs = {
+export const fs = /** @type {const} */ ({
   ...fso,
   ...fso.promises,
   exists: util.promisify(fso.exists),
@@ -16,4 +16,4 @@ export const fs = {
   rmdir,
   rmDir: rmdir,
   watch: fso.watch,
-}
+})

package/src/{getContentType.mjs → getContentType.js}

@@ -1,11 +1,16 @@
-import { getFileType } from './getFileType.mjs'
-import { contentTypes } from './contentTypes.mjs'
-
+import mimes from '@magic/mime-types'
 import is from '@magic/types'
 import error from '@magic/error'
 
+import { getFileType } from './getFileType.js'
+
 const libName = '@magic/fs.getContentType'
 
+/**
+ *
+ * @param {string} uri
+ * @returns {string}
+ */
 export const getContentType = uri => {
   if (is.empty(uri)) {
     throw error(`${libName}: need uri to be a non-empty string`, 'E_ARG_EMPTY')
@@ -17,8 +22,11 @@ export const getContentType = uri => {
 
   const fileType = getFileType(uri)
   let contentType = 'text/plain'
-  if (contentTypes[fileType]) {
-    contentType = contentTypes[fileType]
+
+  const mimeTypes = /** @type {Record<string, string>} */ (mimes)
+
+  if (fileType in mimeTypes) {
+    contentType = mimeTypes[fileType]
   }
 
   return contentType

package/src/getDirectories.js

@@ -0,0 +1,144 @@
+import path from 'node:path'
+
+import is from '@magic/types'
+import deep from '@magic/deep'
+import error from '@magic/error'
+
+import { fs } from './fs.js'
+
+import { getFilePath } from './getFilePath.js'
+
+const libName = '@magic/fs.getDirectories'
+
+/**
+ * @typedef {object} Options
+ * @property {string} [root]
+ * @property {number} [maxDepth]
+ * @property {number} [minDepth]
+ * @property {boolean | number} [depth]
+ * @property {boolean} [noRoot]
+ */
+
+/**
+ * @param {string | string[]} dir
+ * @param {number | false | Options} [options]
+ * if options is a number, its the max depth of recursion.
+ * if it is false, maxDepth is set to 1
+ * @returns {Promise<string[]>}
+ */
+export const getDirectories = async (dir, options = {}) => {
+  if (is.number(options)) {
+    options = {
+      maxDepth: options,
+    }
+  } else if (options === false) {
+    options = {
+      maxDepth: 1,
+    }
+  }
+
+  let { minDepth, maxDepth = false, depth = false, root, noRoot = false } = options
+
+  if (!is.number(maxDepth)) {
+    maxDepth = is.number(depth) ? depth : 200_000
+  }
+
+  if (!is.number(minDepth)) {
+    minDepth = 0
+  }
+
+  if (!is.array(dir) && !is.string(dir)) {
+    throw error(`${libName}: need an array or a string as first argument`, 'E_ARG_TYPE')
+  }
+
+  if (is.empty(dir)) {
+    throw error(`${libName}: first argument can not be empty`, 'E_ARG_EMPTY')
+  }
+
+  if (is.empty(root) && is.string(dir)) {
+    root = dir
+  }
+
+  try {
+    if (is.array(dir)) {
+      const dirs = await Promise.all(dir.map(async f => await 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)
+
+    /** @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')
+        }
+
+        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
+              }
+            }),
+          )
+        }
+      }),
+    )
+
+    let finalDirs = deep.flatten(dirs).filter(a => a)
+    if (!noRoot) {
+      finalDirs = [dir, ...finalDirs]
+    }
+
+    const finalized = finalDirs
+      .filter(a => is.string(a))
+      .filter(dir => {
+        const currentDepth = dir
+          .replace(root || process.cwd(), '')
+          .split(path.sep)
+          .filter(a => a).length
+
+        return currentDepth >= minDepth
+      })
+
+    const unique = Array.from(new Set(finalized))
+
+    return unique
+  } catch (e) {
+    const err = /** @type {import('@magic/error').CustomError} */ (e)
+    if (err.code === 'ENOENT') {
+      return []
+    }
+
+    throw e
+  }
+}

package/src/{getFilePath.mjs → getFilePath.js}

@@ -1,12 +1,27 @@
-import path from 'path'
+import path from 'node:path'
 
 import is from '@magic/types'
 import error from '@magic/error'
 
-import { fs } from './fs.mjs'
+import { fs } from './fs.js'
 
 const libName = '@magic/fs.getFilePath'
 
+/**
+ * @typedef {typeof import('./getFiles.js').getFiles} GetFiles
+ * @typedef {import('./getFiles.js').Options} GetFilesOptions
+ * @typedef {typeof import('./getDirectories.js').getDirectories} GetDirectories
+ *
+ */
+
+/**
+ *
+ * @param {GetFiles | GetDirectories} fn
+ * @param {string} dir
+ * @param {string} file
+ * @param {GetFilesOptions} args
+ * @returns {Promise<string | string[] | undefined>}
+ */
 export const getFilePath = async (fn, dir, file, args = {}) => {
   if (is.empty(fn)) {
     throw error(`${libName}: fn: first argument can not be empty`, 'E_ARG_1_EMPTY')
@@ -32,7 +47,7 @@ export const getFilePath = async (fn, dir, file, args = {}) => {
   const filePath = path.join(dir, file)
 
   const stat = await fs.stat(filePath)
-  if (stat.isDirectory(filePath)) {
+  if (stat.isDirectory()) {
     return await fn(filePath, args)
   } else if (stat.isFile()) {
     return filePath

package/src/{getFileType.mjs → getFileType.js}

@@ -1,4 +1,9 @@
-import path from 'path'
+import path from 'node:path'
 
+/**
+ *
+ * @param {string} name
+ * @returns {string}
+ */
 export const getFileType = name =>
   !name || !name.includes('.') ? 'txt' : path.extname(name).substring(1)

package/src/getFiles.js

@@ -0,0 +1,134 @@
+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'
+
+/**
+ * @typedef {object} Options
+ * @property {number} [minDepth]
+ * @property {number} [maxDepth]
+ * @property {number | false} [depth]
+ * @property {string} [extension]
+ * @property {string} [ext]
+ * @property {string} [root]
+ */
+
+/**
+ * @param {string} dir
+ * First argument: directory to scan
+ * @param {number | Options} [options]
+ * If number, sets maxDepth directly.
+ * @returns {Promise<string[]>}
+ */
+
+export const getFiles = async (dir, options = {}) => {
+  if (is.number(options)) {
+    options = {
+      maxDepth: options,
+    }
+  }
+
+  let {
+    minDepth = 0,
+    maxDepth = false,
+    depth = false,
+    extension = false,
+    ext = false,
+    root = process.cwd(),
+  } = options
+
+  if (ext && !extension) {
+    extension = ext
+  }
+
+  if (!is.number(maxDepth)) {
+    maxDepth = is.number(depth) ? depth : 200_000
+  }
+
+  if (!is.number(minDepth)) {
+    minDepth = 0
+  }
+
+  if (is.empty(dir)) {
+    throw error(`${libName}: dir: first argument can not be empty.`, 'E_ARG_EMPTY')
+  }
+
+  if (!is.string(dir)) {
+    throw error(`${libName}: dir: first argument must be a string.`, 'E_ARG_TYPE')
+  }
+
+  if (is.empty(root)) {
+    root = dir
+  }
+
+  const currentDepth =
+    dir
+      .replace(root, '')
+      .split(path.sep)
+      .filter(a => a).length - 1
+
+  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 }
+        }
+      }),
+    )
+
+    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
+        })
+    )
+  } catch (e) {
+    const err = /** @type {Error & { code?: string }} */ (e)
+    if (err.code === 'ENOENT') {
+      return []
+    }
+
+    throw error(err.message, err.code)
+  }
+}

package/src/index.js

@@ -0,0 +1,24 @@
+import { fs as fso } from './fs.js'
+
+import { mkdirp } from './mkdirp.js'
+import { rmrf } from './rmrf.js'
+import { getFileType } from './getFileType.js'
+import { getDirectories } from './getDirectories.js'
+import { getFiles } from './getFiles.js'
+import { exists } from './exists.js'
+import { getContentType } from './getContentType.js'
+import { getFilePath } from './getFilePath.js'
+
+export const fs = /** @type {const} */ ({
+  ...fso,
+  mkdirp,
+  rmrf,
+  getFileType,
+  getDirectories,
+  getFiles,
+  exists,
+  getContentType,
+  getFilePath,
+})
+
+export default fs

package/src/{mkdirp.mjs → mkdirp.js}

@@ -3,10 +3,15 @@ import path from 'path'
 import error from '@magic/error'
 import is from '@magic/types'
 
-import { fs } from './fs.mjs'
+import { fs } from './fs.js'
 
 const libName = '@magic/fs.mkdirp'
 
+/**
+ *
+ * @param {string} p
+ * @returns {Promise<boolean | void>}
+ */
 export const mkdirp = async p => {
   if (is.empty(p)) {
     throw error(`${libName} expects a non-empty path string as argument.`, 'E_ARG_EMPTY')
@@ -29,10 +34,11 @@ export const mkdirp = async p => {
     await fs.mkdir(p)
     return true
   } catch (e) {
-    if (e.code === 'EEXIST') {
+    const err = /** @type {Error & { code?: string}} */ (e)
+    if (err.code === 'EEXIST') {
       return true
     }
 
-    throw error(e.message, e.code)
+    throw error(err)
   }
 }

package/src/{rmrf.mjs → rmrf.js}

@@ -3,12 +3,25 @@ import path from 'path'
 import is from '@magic/types'
 import error from '@magic/error'
 
-import { fs } from './fs.mjs'
+import { fs } from './fs.js'
 
 const cwd = process.cwd()
 
 const libName = '@magic/fs.rmrf'
 
+/**
+ * @typedef {object} Options
+ * @property {boolean} [dryRun]
+ */
+
+/**
+ * Recursively removes a file or directory.
+ *
+ * @throws {Error} If the argument is invalid, outside cwd, or fs operations fail.
+ * @param {string} dir
+ * @param {Options} [opts]
+ * @returns {Promise<boolean | undefined>}
+ */
 export const rmrf = async (dir, opts = {}) => {
   if (is.empty(dir)) {
     throw error(`${libName}: expecting a non-empty argument.`, 'E_DIR_EMPTY')
@@ -45,10 +58,12 @@ export const rmrf = async (dir, opts = {}) => {
       return true
     }
   } catch (e) {
-    if (e.code === 'ENOENT') {
+    const err = /** @type {Error & { code?: string}} */ (e)
+
+    if (err.code === 'ENOENT') {
       return true
     }
 
-    throw error(e)
+    throw error(err)
   }
 }

package/types/exists.d.ts

@@ -0,0 +1,2 @@
+/** @type {(f: import('node:fs').PathLike) => Promise<boolean>} */
+export const exists: (f: import('node:fs').PathLike) => Promise<boolean>

package/types/fs.d.ts

@@ -0,0 +1,109 @@
+export const fs: {
+  readonly exists: typeof fso.exists.__promisify__
+  readonly readdir: typeof fso.promises.readdir
+  readonly readDir: typeof fso.promises.readdir
+  readonly readFile: typeof fso.promises.readFile
+  readonly readfile: typeof fso.promises.readFile
+  readonly rmdir: typeof fso.promises.rmdir
+  readonly rmDir: typeof fso.promises.rmdir
+  readonly watch: typeof fso.watch
+  readonly access: typeof fso.promises.access
+  readonly copyFile: typeof fso.promises.copyFile
+  readonly open: typeof fso.promises.open
+  readonly rename: typeof fso.promises.rename
+  readonly truncate: typeof fso.promises.truncate
+  readonly rm: typeof fso.promises.rm
+  readonly mkdir: typeof fso.promises.mkdir
+  readonly readlink: typeof fso.promises.readlink
+  readonly symlink: typeof fso.promises.symlink
+  readonly lstat: typeof fso.promises.lstat
+  readonly stat: typeof fso.promises.stat
+  readonly statfs: typeof fso.promises.statfs
+  readonly link: typeof fso.promises.link
+  readonly unlink: typeof fso.promises.unlink
+  readonly chmod: typeof fso.promises.chmod
+  readonly lchmod: typeof fso.promises.lchmod
+  readonly lchown: typeof fso.promises.lchown
+  readonly lutimes: typeof fso.promises.lutimes
+  readonly chown: typeof fso.promises.chown
+  readonly utimes: typeof fso.promises.utimes
+  readonly realpath: typeof fso.promises.realpath
+  readonly mkdtemp: typeof fso.promises.mkdtemp
+  readonly mkdtempDisposable: typeof fso.promises.mkdtempDisposable
+  readonly writeFile: typeof fso.promises.writeFile
+  readonly appendFile: typeof fso.promises.appendFile
+  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
+  readonly ftruncateSync: typeof fso.ftruncateSync
+  readonly chownSync: typeof fso.chownSync
+  readonly fchown: typeof fso.fchown
+  readonly fchownSync: typeof fso.fchownSync
+  readonly lchownSync: typeof fso.lchownSync
+  readonly lutimesSync: typeof fso.lutimesSync
+  readonly chmodSync: typeof fso.chmodSync
+  readonly fchmod: typeof fso.fchmod
+  readonly fchmodSync: typeof fso.fchmodSync
+  readonly lchmodSync: typeof fso.lchmodSync
+  readonly fstat: typeof fso.fstat
+  readonly fstatSync: typeof fso.fstatSync
+  readonly statfsSync: typeof fso.statfsSync
+  readonly linkSync: typeof fso.linkSync
+  readonly symlinkSync: typeof fso.symlinkSync
+  readonly readlinkSync: typeof fso.readlinkSync
+  readonly realpathSync: typeof fso.realpathSync
+  readonly unlinkSync: typeof fso.unlinkSync
+  readonly rmdirSync: typeof fso.rmdirSync
+  readonly rmSync: typeof fso.rmSync
+  readonly mkdirSync: typeof fso.mkdirSync
+  readonly mkdtempSync: typeof fso.mkdtempSync
+  readonly mkdtempDisposableSync: typeof fso.mkdtempDisposableSync
+  readonly readdirSync: typeof fso.readdirSync
+  readonly close: typeof fso.close
+  readonly closeSync: typeof fso.closeSync
+  readonly openSync: typeof fso.openSync
+  readonly utimesSync: typeof fso.utimesSync
+  readonly futimes: typeof fso.futimes
+  readonly futimesSync: typeof fso.futimesSync
+  readonly fsync: typeof fso.fsync
+  readonly fsyncSync: typeof fso.fsyncSync
+  readonly write: typeof fso.write
+  readonly writeSync: typeof fso.writeSync
+  readonly read: typeof fso.read
+  readonly readSync: typeof fso.readSync
+  readonly readFileSync: typeof fso.readFileSync
+  readonly writeFileSync: typeof fso.writeFileSync
+  readonly appendFileSync: typeof fso.appendFileSync
+  readonly watchFile: typeof fso.watchFile
+  readonly unwatchFile: typeof fso.unwatchFile
+  readonly existsSync: typeof fso.existsSync
+  readonly accessSync: typeof fso.accessSync
+  readonly createReadStream: typeof fso.createReadStream
+  readonly createWriteStream: typeof fso.createWriteStream
+  readonly fdatasync: typeof fso.fdatasync
+  readonly fdatasyncSync: typeof fso.fdatasyncSync
+  readonly copyFileSync: typeof fso.copyFileSync
+  readonly writev: typeof fso.writev
+  readonly writevSync: typeof fso.writevSync
+  readonly readv: typeof fso.readv
+  readonly readvSync: typeof fso.readvSync
+  readonly openAsBlob: typeof fso.openAsBlob
+  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
+  readonly Dir: typeof fso.Dir
+  readonly ReadStream: typeof fso.ReadStream
+  readonly Utf8Stream: typeof fso.Utf8Stream
+  readonly WriteStream: typeof fso.WriteStream
+  readonly statSync: fso.StatSyncFn
+  readonly lstatSync: fso.StatSyncFn
+}
+import fso from 'node:fs'

package/types/getContentType.d.ts

@@ -0,0 +1 @@
+export function getContentType(uri: string): string

package/types/getDirectories.d.ts

@@ -0,0 +1,11 @@
+export function getDirectories(
+  dir: string | string[],
+  options?: number | false | Options,
+): Promise<string[]>
+export type Options = {
+  root?: string | undefined
+  maxDepth?: number | undefined
+  minDepth?: number | undefined
+  depth?: number | boolean | undefined
+  noRoot?: boolean | undefined
+}

package/types/getFilePath.d.ts

@@ -0,0 +1,9 @@
+export function getFilePath(
+  fn: GetFiles | GetDirectories,
+  dir: string,
+  file: string,
+  args?: GetFilesOptions,
+): Promise<string | string[] | undefined>
+export type GetFiles = typeof import('./getFiles.js').getFiles
+export type GetFilesOptions = import('./getFiles.js').Options
+export type GetDirectories = typeof import('./getDirectories.js').getDirectories

package/types/getFileType.d.ts

@@ -0,0 +1 @@
+export function getFileType(name: string): string

package/types/getFiles.d.ts

@@ -0,0 +1,9 @@
+export function getFiles(dir: string, options?: number | Options): Promise<string[]>
+export type Options = {
+  minDepth?: number | undefined
+  maxDepth?: number | undefined
+  depth?: number | false | undefined
+  extension?: string | undefined
+  ext?: string | undefined
+  root?: string | undefined
+}

package/types/index.d.ts

@@ -0,0 +1,124 @@
+export const fs: {
+  readonly mkdirp: (p: string) => Promise<boolean | void>
+  readonly rmrf: (dir: string, opts?: Options) => Promise<boolean | undefined>
+  readonly getFileType: (name: string) => string
+  readonly getDirectories: (
+    dir: string | string[],
+    options?: number | false | Options,
+  ) => Promise<string[]>
+  readonly getFiles: (dir: string, options?: number | Options) => Promise<string[]>
+  readonly exists: (f: import('fs').PathLike) => Promise<boolean>
+  readonly getContentType: (uri: string) => string
+  readonly getFilePath: (
+    fn: GetFiles | GetDirectories,
+    dir: string,
+    file: string,
+    args?: GetFilesOptions,
+  ) => 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 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

@@ -0,0 +1 @@
+export function mkdirp(p: string): Promise<boolean | void>

package/types/rmrf.d.ts

@@ -0,0 +1,4 @@
+export function rmrf(dir: string, opts?: Options): Promise<boolean | undefined>
+export type Options = {
+  dryRun?: boolean | undefined
+}

package/src/contentTypes.mjs

@@ -1,3 +0,0 @@
-import mimeTypes from '@magic/mime-types'
-
-export const contentTypes = mimeTypes

package/src/getDirectories.mjs

@@ -1,137 +0,0 @@
-import path from 'path'
-
-import is from '@magic/types'
-import deep from '@magic/deep'
-import error from '@magic/error'
-import log from '@magic/log'
-
-import { fs } from './fs.mjs'
-
-import { getFilePath } from './getFilePath.mjs'
-
-const libName = '@magic/fs.getDirectories'
-
-export const getDirectories = async (dir, args = {}) => {
-  if (is.number(args)) {
-    args = {
-      maxDepth: args,
-    }
-  } else if (args === false) {
-    args = {
-      maxDepth: 1,
-    }
-  }
-
-  let { minDepth, maxDepth = false, depth = false, root, noRoot = false } = args
-
-  if (is.number(depth) && !is.number(maxDepth)) {
-    maxDepth = depth
-  }
-
-  if (!is.number(maxDepth)) {
-    maxDepth = 200_000
-  }
-  if (!is.number(minDepth)) {
-    minDepth = 0
-  }
-
-  if (!is.array(dir) && !is.string(dir)) {
-    throw error(`${libName}: need an array or a string as first argument`, 'E_ARG_TYPE')
-  }
-
-  if (is.empty(dir)) {
-    throw error(`${libName}: first argument can not be empty`, 'E_ARG_EMPTY')
-  }
-
-  if (is.empty(root)) {
-    if (is.string(dir)) {
-      root = dir
-    } else {
-      root = process.cwd()
-    }
-  }
-
-  try {
-    if (is.array(dir)) {
-      const dirs = await Promise.all(
-        dir.map(async f => await getDirectories(f, { maxDepth, minDepth, root, noRoot })),
-      )
-
-      return deep.flatten(...dirs).filter(a => a)
-    }
-
-    const currentDepth = dir
-      .replace(root, '')
-      .split(path.sep)
-      .filter(a => a).length
-
-    if (currentDepth > maxDepth) {
-      return []
-    }
-
-    const dirContent = await fs.readdir(dir)
-
-    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')
-        }
-
-        let filePath = await getFilePath(getDirectories, dir, file, { maxDepth, minDepth, root })
-
-        if (filePath) {
-          if (!is.array(filePath)) {
-            filePath = [filePath]
-          }
-
-          const files = await Promise.all(
-            filePath.map(async file => {
-              if (!is.string(file)) {
-                throw error(`${libName}: path was not a string: ${file}`, 'E_ARG_TYPE')
-              }
-
-              const stat = await fs.stat(file)
-              if (stat.isDirectory()) {
-                return filePath
-              }
-            }),
-          )
-
-          return files
-        }
-
-        return
-      }),
-    )
-
-    let finalDirs = deep.flatten(dirs).filter(a => a)
-    if (!noRoot) {
-      finalDirs = [dir, ...finalDirs]
-    }
-
-    const finalized = finalDirs
-      .filter(a => a)
-      .filter(dir => {
-        if (is.number(minDepth)) {
-          const currentDepth = dir
-            .replace(root, '')
-            .split(path.sep)
-            .filter(a => a).length
-
-          return currentDepth >= minDepth
-        }
-
-        return false
-      })
-
-    const unique = Array.from(new Set(finalized))
-
-    return unique
-  } catch (e) {
-    if (e.code === 'ENOENT') {
-      return []
-    }
-
-    throw e
-  }
-}

package/src/getFiles.mjs

@@ -1,107 +0,0 @@
-import path from 'path'
-
-import deep from '@magic/deep'
-import is from '@magic/types'
-import error from '@magic/error'
-
-import { getFilePath } from './getFilePath.mjs'
-import { fs } from './fs.mjs'
-
-const libName = '@magic/fs.getFiles'
-
-export const getFiles = async (dir, args = {}) => {
-  if (is.number(args)) {
-    args = {
-      maxDepth: args,
-    }
-  }
-
-  let { minDepth = 0, maxDepth = false, depth = false, extension = false, ext = false, root } = args
-
-  if (ext && !extension) {
-    extension = ext
-  }
-
-  if (is.number(depth) && !is.number(maxDepth)) {
-    maxDepth = depth
-  }
-
-  if (!is.number(maxDepth)) {
-    maxDepth = 200_000
-  }
-  if (!is.number(minDepth)) {
-    minDepth = 0
-  }
-
-  if (is.empty(dir)) {
-    throw error(`${libName}: dir: first argument can not be empty.`, 'E_ARG_EMPTY')
-  }
-
-  if (!is.string(dir)) {
-    throw error(`${libName}: dir: first argument must be a string.`, 'E_ARG_TYPE')
-  }
-
-  if (is.empty(root)) {
-    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 })),
-    )
-
-    return await Promise.all(
-      deep
-        .flatten(files)
-        .filter(a => 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
-         */
-        .filter(async f => {
-          const stat = await fs.stat(f)
-          return stat.isFile()
-        })
-        /*
-         * filter files if depth is smaller than minDepth
-         */
-        .filter(file => {
-          if (!file) {
-            return false
-          }
-
-          if (is.number(minDepth)) {
-            const currentDepth =
-              file
-                .replace(root, '')
-                .split(path.sep)
-                .filter(a => a).length - 1
-
-            return currentDepth >= minDepth
-          }
-
-          return true
-        }),
-    )
-  } catch (e) {
-    if (e.code === 'ENOENT') {
-      return []
-    }
-
-    throw error(e.message, e.code)
-  }
-}

package/src/index.mjs

@@ -1,24 +0,0 @@
-import { fs as fso } from './fs.mjs'
-
-import { mkdirp } from './mkdirp.mjs'
-import { rmrf } from './rmrf.mjs'
-import { getFileType } from './getFileType.mjs'
-import { getDirectories } from './getDirectories.mjs'
-import { getFiles } from './getFiles.mjs'
-import { exists } from './exists.mjs'
-import { getContentType } from './getContentType.mjs'
-import { getFilePath } from './getFilePath.mjs'
-
-export const fs = {
-  ...fso,
-  mkdirp,
-  rmrf,
-  getFileType,
-  getDirectories,
-  getFiles,
-  exists,
-  getContentType,
-  getFilePath,
-}
-
-export default fs