@visulima/fs/dist/packem_shared/walkSync-BidUqvMI.cjs

Human friendly file system utilities for Node.js

'use strict';

const node_fs = require('node:fs');
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((path$1) => {
  const normalizePath = path.normalize(path$1);
  const info = node_fs.statSync(normalizePath);
  return {
    // eslint-disable-next-line @typescript-eslint/unbound-method
    isDirectory: info.isDirectory,
    // eslint-disable-next-line @typescript-eslint/unbound-method
    isFile: info.isFile,
    // eslint-disable-next-line @typescript-eslint/unbound-method
    isSymbolicLink: info.isSymbolicLink,
    name: path.basename(normalizePath),
    path: normalizePath
  };
}, "_createWalkEntry");
function* walkSync(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 _createWalkEntry(directory);
  }
  if (maxDepth < 1 || !walkInclude.walkInclude(directory, void 0, void 0, mappedSkip)) {
    return;
  }
  try {
    for (const entry of node_fs.readdirSync(directory, {
      withFileTypes: true
    })) {
      let path$1 = path.join(directory, entry.name);
      if (entry.isSymbolicLink()) {
        if (followSymlinks) {
          path$1 = node_fs.realpathSync(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.normalize(path$1)
          };
        } else {
          continue;
        }
      }
      if (entry.isSymbolicLink() || entry.isDirectory()) {
        yield* walkSync(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 {
          // 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.normalize(path$1)
        };
      }
    }
  } catch (error) {
    if (error instanceof WalkError) {
      throw error;
    }
    throw new WalkError(error, directory);
  }
}
__name(walkSync, "walkSync");

module.exports = walkSync;