@magic/fs 0.0.29 → 0.0.30

package/README.md

@@ -301,7 +301,13 @@ update dependencies
 - update dependencies
 - getFiles and getDirectories now accept maxDepth and minDepth config args
 
-##### 0.0.30 - unreleased
+##### 0.0.30
+
+- update dependencies
+- remove deprecated getFiles and getDirectories api
+- add minDepth option
+
+##### 0.0.31 - unreleased
 
 ...
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic/fs",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "author": "Wizards & Witches",
   "description": "nodejs fs promises + goodies",
   "license": "AGPL-3.0",
@@ -37,8 +37,8 @@
     "@magic-modules/no-spy": "0.0.9",
     "@magic-modules/pre": "0.0.12",
     "@magic-themes/docs": "0.0.15",
-    "@magic/core": "0.0.155",
-    "@magic/format": "0.0.52",
+    "@magic/core": "0.0.156",
+    "@magic/format": "0.0.54",
     "@magic/test": "0.2.18"
   },
   "dependencies": {

package/src/getDirectories.mjs

@@ -11,39 +11,29 @@ import { getFilePath } from './getFilePath.mjs'
 
 const libName = '@magic/fs.getDirectories'
 
-export const getDirectories = async (dir, depth = {}, root = 'deprecated') => {
-  if (root !== 'deprecated') {
-    log.warn('E_DEPRECATED', 'you have used fs.getDirectories with a third argument.')
-    log.info('Please use the new syntax instead:')
-    log.info('fs.getDirectories(dir, { root: true })')
-  } else {
-    root = false
+export const getDirectories = async (dir, args = {}) => {
+  if (is.number(args)) {
+    args = {
+      maxDepth: args,
+    }
+  } else if (args === false) {
+    args = {
+      maxDepth: 1,
+    }
   }
 
-  let minDepth = 0
-  let maxDepth = 200
+  let { minDepth, maxDepth = false, depth = false, root, noRoot = false } = args
 
-  let noRoot = false
-  if (depth === false) {
-    maxDepth = 1
-  } else if (is.number(depth)) {
+  if (is.number(depth) && !is.number(maxDepth)) {
     maxDepth = depth
-  } else if (!is.empty(depth) && is.objectNative(depth)) {
-    root = root || depth?.root
-    noRoot = depth?.noRoot
-
-    if (depth.hasOwnProperty('depth')) {
-      maxDepth = depth.depth
-    } else if (depth.hasOwnProperty('maxDepth')) {
-      maxDepth = depth.maxDepth
-    }
-
-    if (depth.hasOwnProperty('minDepth')) {
-      minDepth = depth.minDepth
-    }
   }
 
-  maxDepth = parseInt(maxDepth)
+  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')
@@ -70,8 +60,12 @@ export const getDirectories = async (dir, depth = {}, root = 'deprecated') => {
       return deep.flatten(...dirs).filter(a => a)
     }
 
-    const currentDepth = dir.replace(root, '').split(path.sep).length
-    if (is.number(maxDepth) && currentDepth - 1 > maxDepth) {
+    const currentDepth = dir
+      .replace(root, '')
+      .split(path.sep)
+      .filter(a => a).length
+
+    if (currentDepth > maxDepth) {
       return []
     }
 
@@ -110,24 +104,25 @@ export const getDirectories = async (dir, depth = {}, root = 'deprecated') => {
       }),
     )
 
-    let finalDirs = dirs.filter(a => a)
+    let finalDirs = deep.flatten(dirs).filter(a => a)
     if (!noRoot) {
       finalDirs = [dir, ...finalDirs]
     }
 
-    const finalized = deep.flatten(finalDirs).filter(dir => {
-      if (!dir) {
-        return false
-      }
-
-      if (is.number(minDepth)) {
-        const currentDepth = dir.replace(root, '').split(path.sep).length
+    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 currentDepth >= minDepth
+        }
 
-      return true
-    })
+        return false
+      })
 
     const unique = Array.from(new Set(finalized))
 

package/src/getFilePath.mjs

@@ -2,30 +2,12 @@ import path from 'path'
 
 import is from '@magic/types'
 import error from '@magic/error'
-import log from '@magic/log'
 
 import { fs } from './fs.mjs'
 
 const libName = '@magic/fs.getFilePath'
 
-export const getFilePath = async (fn, dir, file, depth = true, root = 'deprecated') => {
-  if (root !== 'deprecated') {
-    log.warn('E_DEPRECATED', 'you have used fs.getFilePath with a fifth argument.')
-    log.info('Please use the new syntax instead:')
-    log.info("fs.getFilePath(fn, dir, file, { depth: true || 22, root: false || '/some/dir/' })")
-  } else {
-    root = false
-  }
-
-  let minDepth = 0
-  let maxDepth = 200
-
-  if (!is.empty(depth) && is.objectNative(depth)) {
-    root = depth.root
-    maxDepth = depth?.depth || depth?.maxDepth
-    minDepth = depth?.minDepth
-  }
-
+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')
   }
@@ -51,14 +33,7 @@ export const getFilePath = async (fn, dir, file, depth = true, root = 'deprecate
 
   const stat = await fs.stat(filePath)
   if (stat.isDirectory(filePath)) {
-    const currentDepth = filePath
-      .replace(root, '')
-      .split(path.sep)
-      .filter(a => a).length
-
-    if (maxDepth || currentDepth === 1) {
-      return await fn(filePath, { maxDepth, minDepth, root })
-    }
+    return await fn(filePath, args)
   } else if (stat.isFile()) {
     return filePath
   }

package/src/getFiles.mjs

@@ -3,46 +3,36 @@ import path from 'path'
 import deep from '@magic/deep'
 import is from '@magic/types'
 import error from '@magic/error'
-import log from '@magic/log'
 
 import { getFilePath } from './getFilePath.mjs'
 import { fs } from './fs.mjs'
 
 const libName = '@magic/fs.getFiles'
 
-export const getFiles = async (dir, depth = true, root = 'deprecated') => {
-  if (root !== 'deprecated') {
-    log.warn('E_DEPRECATED', 'you have used fs.getFiles with a third argument.')
-    log.info('Please use the new syntax instead:')
-    log.info("fs.getFiles(dir, { maxDepth: 200, root: false, extension: 'md', minDepth: 0 })")
-  } else {
-    root = false
+export const getFiles = async (dir, args = {}) => {
+  if (is.number(args)) {
+    args = {
+      maxDepth: args,
+    }
   }
 
-  let minDepth = 0
-  let maxDepth = 200
+  let { minDepth = 0, maxDepth = false, depth = false, extension = false, ext = false, root } = args
 
-  let extension
+  if (ext && !extension) {
+    extension = ext
+  }
 
-  if (depth === false) {
-    maxDepth = 1
-  } else if (is.number(depth)) {
+  if (is.number(depth) && !is.number(maxDepth)) {
     maxDepth = depth
   }
-  if (!is.empty(depth) && is.objectNative(depth)) {
-    root = root || depth?.root
-    extension = depth?.extension
 
-    maxDepth = depth?.depth || depth?.maxDepth
-    minDepth = depth.minDepth
+  if (!is.number(maxDepth)) {
+    maxDepth = 200_000
   }
-
-  if (maxDepth === false) {
-    maxDepth = 1
+  if (!is.number(minDepth)) {
+    minDepth = 0
   }
 
-  maxDepth = parseInt(maxDepth)
-
   if (is.empty(dir)) {
     throw error(`${libName}: dir: first argument can not be empty.`, 'E_ARG_EMPTY')
   }
@@ -51,13 +41,16 @@ export const getFiles = async (dir, depth = true, root = 'deprecated') => {
     throw error(`${libName}: dir: first argument must be a string.`, 'E_ARG_TYPE')
   }
 
-  if (is.empty(root) && is.number(maxDepth)) {
+  if (is.empty(root)) {
     root = dir
   }
 
-  const currentDepth = dir.replace(root, '').split(path.sep).length
+  const currentDepth = dir
+    .replace(root, '')
+    .split(path.sep)
+    .filter(a => a).length
 
-  if (is.number(maxDepth) && currentDepth - 1 > maxDepth) {
+  if (currentDepth > maxDepth) {
     return []
   }
 
@@ -92,9 +85,13 @@ export const getFiles = async (dir, depth = true, root = 'deprecated') => {
           }
 
           if (is.number(minDepth)) {
-            const currentDepth = file.replace(root, '').split(path.sep).length
+            const currentDepth =
+              file
+                .replace(root, '')
+                .split(path.sep)
+                .filter(a => a).length - 1
 
-            return currentDepth > minDepth
+            return currentDepth >= minDepth
           }
 
           return true