@visulima/fs/dist/packem_shared/walk-PpNwjtjX.cjs

Human friendly file system utilities for Node.js

'use strict';

const promises = require('node:fs/promises');
const path = require('@visulima/path');
const utils = require('@visulima/path/utils');
const WalkError = require('./WalkError-B7_AVs7d.cjs');
const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
const walkInclude = require('./walk-include-yUdRrF16.cjs');

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
const _createWalkEntry = /* @__PURE__ */ __name(async (path$1) => {
  const normalizePath = path.normalize(path$1);
  const name = path.basename(normalizePath);
  const info = await promises.stat(normalizePath);
  return {
    isDirectory: /* @__PURE__ */ __name(() => info.isDirectory(), "isDirectory"),
    isFile: /* @__PURE__ */ __name(() => info.isFile(), "isFile"),
    isSymbolicLink: /* @__PURE__ */ __name(() => info.isSymbolicLink(), "isSymbolicLink"),
    name,
    path: normalizePath
  };
}, "_createWalkEntry");
async function* walk(directory, {
  extensions,
  followSymlinks = false,
  includeDirs: includeDirectories = true,
  includeFiles = true,
  includeSymlinks = true,
  match,
  maxDepth = Number.POSITIVE_INFINITY,
  skip
} = {}) {
  assertValidFileOrDirectoryPath(directory);
  if (maxDepth < 0) {
    return;
  }
  const mappedMatch = match ? match.map((pattern) => typeof pattern === "string" ? walkInclude.globToRegExp(pattern) : pattern) : void 0;
  const mappedSkip = skip ? skip.map((pattern) => typeof pattern === "string" ? walkInclude.globToRegExp(pattern) : pattern) : void 0;
  directory = path.resolve(utils.toPath(directory));
  if (includeDirectories && walkInclude.walkInclude(directory, extensions, mappedMatch, mappedSkip)) {
    yield await _createWalkEntry(directory);
  }
  if (maxDepth < 1 || !walkInclude.walkInclude(directory, void 0, void 0, mappedSkip)) {
    return;
  }
  try {
    for await (const entry of await promises.readdir(directory, {
      withFileTypes: true
    })) {
      let path$1 = path.join(directory, entry.name);
      if (entry.isSymbolicLink()) {
        if (followSymlinks) {
          path$1 = await promises.realpath(path$1);
        } else if (includeSymlinks && walkInclude.walkInclude(path$1, extensions, mappedMatch, mappedSkip)) {
          yield {
            // eslint-disable-next-line @typescript-eslint/unbound-method
            isDirectory: entry.isDirectory,
            // eslint-disable-next-line @typescript-eslint/unbound-method
            isFile: entry.isFile,
            // eslint-disable-next-line @typescript-eslint/unbound-method
            isSymbolicLink: entry.isSymbolicLink,
            name: entry.name,
            path: path$1
          };
        } else {
          continue;
        }
      }
      if (entry.isSymbolicLink() || entry.isDirectory()) {
        yield* walk(path$1, {
          extensions,
          followSymlinks,
          includeDirs: includeDirectories,
          includeFiles,
          includeSymlinks,
          match: mappedMatch,
          maxDepth: maxDepth - 1,
          skip: mappedSkip
        });
      } else if (entry.isFile() && includeFiles && walkInclude.walkInclude(path$1, extensions, mappedMatch, mappedSkip)) {
        yield {
          isDirectory: /* @__PURE__ */ __name(() => entry.isDirectory(), "isDirectory"),
          isFile: /* @__PURE__ */ __name(() => entry.isFile(), "isFile"),
          isSymbolicLink: /* @__PURE__ */ __name(() => entry.isSymbolicLink(), "isSymbolicLink"),
          name: entry.name,
          path: path$1
        };
      }
    }
  } catch (error) {
    if (error instanceof WalkError) {
      throw error;
    }
    throw new WalkError(error, directory);
  }
}
__name(walk, "walk");

module.exports = walk;