fs-visitor/dist/index.cjs

A Node.js library for recursively listing files and directories with customizable filtering and sorting options.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  default: () => src_default,
  processVisitor: () => processVisitor
});
module.exports = __toCommonJS(src_exports);
var import_fs2 = __toESM(require("fs"), 1);
var import_path = __toESM(require("path"), 1);

// src/model.ts
var assertConfig = ({
  cwd = process.cwd(),
  deep = Infinity,
  relativePrefix = "",
  useSlash = true,
  withDirectory = false,
  asTree = false,
  filterEntry = [],
  sorter = (a, b) => {
    return a.level > b.level ? -1 : a.level < b.level ? 1 : 0;
  }
} = {}) => {
  const filterEntryArray = Array.isArray(filterEntry) ? filterEntry : [filterEntry];
  return {
    cwd,
    deep,
    relativePrefix,
    useSlash,
    asTree,
    withDirectory,
    filterEntry: filterEntryArray,
    sorter
  };
};

// src/utils.ts
var import_fs = __toESM(require("fs"), 1);
var createErrorDirectory = (name) => () => {
  throw new Error(`Entry: ${name} is a directory`);
};
var createReadFileSync = ({ type, name, absolute }) => {
  return type === "file" ? (opts) => import_fs.default.readFileSync(absolute, opts) : createErrorDirectory(name);
};
var createWriteFileSync = ({ type, name, absolute }) => {
  return type === "file" ? (data, opts = {}) => import_fs.default.writeFileSync(absolute, data, opts) : createErrorDirectory(name);
};
var createAppendFileSync = ({ type, name, absolute }) => {
  return type === "file" ? (data, opts = {}) => import_fs.default.writeFileSync(absolute, data, opts) : createErrorDirectory(name);
};

// src/index.ts
var processEntries = (parent, config, entryCallback) => {
  const nextLevel = parent.level + 1;
  if (nextLevel > config.deep) {
    return;
  }
  import_fs2.default.readdirSync(parent.absolute, { withFileTypes: true }).map((entry) => {
    const name = entry.name;
    const type = entry.isDirectory() ? "directory" : entry.isFile() ? "file" : "";
    const absolute = import_path.default.join(parent.absolute, name);
    const relative = import_path.default.join(parent.relative, name);
    return {
      level: nextLevel,
      type,
      name,
      absolute,
      relative,
      children: []
    };
  }).map((current) => {
    if (config.useSlash) {
      current.absolute = current.absolute.replace(/\\/g, "/");
      current.relative = current.relative.replace(/\\/g, "/");
    }
    return current;
  }).filter((current) => {
    return current.type === "directory" || config.filterEntry.length === 0 || config.filterEntry.some((filterCallback) => filterCallback(current));
  }).map((currentBase) => {
    return {
      ...currentBase,
      readFileSync: createReadFileSync(currentBase),
      writeFileSync: createWriteFileSync(currentBase),
      appendFileSync: createAppendFileSync(currentBase)
    };
  }).forEach((current) => {
    if (current.type === "directory") {
      if (config.withDirectory || config.asTree) {
        entryCallback(current, parent);
      }
      processEntries(current, config, entryCallback);
    } else if (current.type === "file") {
      entryCallback(current, parent);
    }
  });
};
var processVisitor = (directory, opts = {}) => {
  const config = assertConfig(opts);
  const result = [];
  const errorRoot = createErrorDirectory("root");
  const root = {
    level: 0,
    name: "",
    type: "directory",
    absolute: import_path.default.join(config.cwd, directory),
    relative: config.relativePrefix,
    children: [],
    appendFileSync: errorRoot,
    writeFileSync: errorRoot,
    readFileSync: errorRoot
  };
  processEntries(root, config, (current, parent) => {
    if (config.asTree) {
      parent.children.push(current);
    } else {
      result.push(current);
    }
  });
  return config.asTree ? [root] : result.sort(config.sorter);
};
var src_default = processVisitor;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  processVisitor
});