commit node_modules

node_modules/async-folder-walker/index.js

@@ -0,0 +1,179 @@
+const fs = require('fs')
+const path = require('path')
+
+const { readdir, lstat } = fs.promises
+
+/**
+ * pathFilter lets you filter files based on a resolved `filepath`.
+ * @callback pathFilter
+ * @param {String} filepath - The resolved `filepath` of the file to test for filtering.
+ *
+ * @return {Boolean} Return false to filter the given `filepath` and true to include it.
+ */
+const pathFilter = filepath => true
+
+/**
+ * statFilter lets you filter files based on a lstat object.
+ * @callback statFilter
+ * @param {Object} st - A fs.Stats instance.
+ *
+ * @return {Boolean} Return false to filter the given `filepath` and true to include it.
+ */
+const statFilter = filepath => true
+
+/**
+ * FWStats is the object that the okdistribute/folder-walker module returns by default.
+ *
+ * @typedef FWStats
+ * @property {String} root - The filepath of the directory where the walk started.
+ * @property {String} filepath - The resolved filepath.
+ * @property {Object} stat - A fs.Stats instance.
+ * @property {String} relname - The relative path to `root`.
+ * @property {String} basename - The resolved filepath of the files containing directory.
+ */
+
+/**
+ * shaper lets you change the shape of the returned file data from walk-time stats.
+ * @callback shaper
+ * @param {FWStats} fwStats - The same status object returned from folder-walker.
+ *
+ * @return {*} - Whatever you want returned from the directory walk.
+ */
+const shaper = ({ root, filepath, stat, relname, basename }) => filepath
+
+/**
+ * Options object
+ *
+ * @typedef Opts
+ * @property {pathFilter} [pathFilter] - A pathFilter cb.
+ * @property {statFilter} [statFilter] - A statFilter cb.
+ * @property {Number} [maxDepth=Infinity] - The maximum number of folders to walk down into.
+ * @property {shaper} [shaper] - A shaper cb.
+ */
+
+/**
+ * Create an async generator that iterates over all folders and directories inside of `dirs`.
+ *
+ * @async
+ * @generator
+ * @function
+ * @public
+ * @param {String|String[]} dirs - The path of the directory to walk, or an array of directory paths.
+ * @param {?(Opts)} opts - Options used for the directory walk.
+ *
+ * @yields {Promise<String|any>} - An async iterator that returns anything.
+ */
+async function * asyncFolderWalker (dirs, opts) {
+  opts = Object.assign({
+    fs,
+    pathFilter,
+    statFilter,
+    maxDepth: Infinity,
+    shaper
+  }, opts)
+
+  const roots = [dirs].flat().filter(opts.pathFilter)
+  const pending = []
+
+  while (roots.length) {
+    const root = roots.shift()
+    pending.push(root)
+
+    while (pending.length) {
+      const current = pending.shift()
+      if (typeof current === 'undefined') continue
+      const st = await lstat(current)
+      if ((!st.isDirectory() || depthLimiter(current, root, opts.maxDepth)) && opts.statFilter(st)) {
+        yield opts.shaper(fwShape(root, current, st))
+        continue
+      }
+
+      const files = await readdir(current)
+      files.sort()
+
+      for (const file of files) {
+        var next = path.join(current, file)
+        if (opts.pathFilter(next)) pending.unshift(next)
+      }
+      if (current === root || !opts.statFilter(st)) continue
+      else yield opts.shaper(fwShape(root, current, st))
+    }
+  }
+}
+
+/**
+ * Generates the same shape as the folder-walker module.
+ *
+ * @function
+ * @private
+ * @param {String} root - Root filepath.
+ * @param {String} name - Target filepath.
+ * @param {Object} st - fs.Stat object.
+ *
+ * @return {FWStats} - Folder walker object.
+ */
+function fwShape (root, name, st) {
+  return {
+    root: root,
+    filepath: name,
+    stat: st,
+    relname: root === name ? path.basename(name) : path.relative(root, name),
+    basename: path.basename(name)
+  }
+}
+
+/**
+ * Test if we are at maximum directory depth.
+ *
+ * @private
+ * @function
+ * @param {String} filePath - The resolved path of the target fille.
+ * @param {String} relativeTo - The root directory of the current walk.
+ * @param {Number} maxDepth - The maximum number of folders to descend into.
+ *
+ * @returns {Boolean} - Return true to signal stop descending.
+ */
+function depthLimiter (filePath, relativeTo, maxDepth) {
+  if (maxDepth === Infinity) return false
+  const rootDepth = relativeTo.split(path.sep).length
+  const fileDepth = filePath.split(path.sep).length
+  return fileDepth - rootDepth > maxDepth
+}
+
+/**
+ * Async iterable collector
+ *
+ * @async
+ * @function
+ * @private
+ */
+async function all (iterator) {
+  const collect = []
+
+  for await (const result of iterator) {
+    collect.push(result)
+  }
+
+  return collect
+}
+
+/**
+ * allFiles gives you all files from the directory walk as an array.
+ *
+ * @async
+ * @function
+ * @public
+ * @param {String|String[]} dirs - The path of the directory to walk, or an array of directory paths.
+ * @param {?(Opts)} opts - Options used for the directory walk.
+ *
+ * @returns {Promise<String[]|any>} - An async iterator that returns anything.
+ */
+async function allFiles (...args) {
+  return all(asyncFolderWalker(...args))
+}
+
+module.exports = {
+  asyncFolderWalker,
+  allFiles,
+  all
+}