@impactor/nodejs 3.0.1

package/src/fs-sync.js

@@ -0,0 +1,212 @@
+import {
+  resolve as _resolve,
+  basename,
+  dirname,
+  extname,
+  join,
+  normalize,
+  sep
+} from "node:path";
+import { objectType } from "@impactor/javascript";
+import {
+  existsSync,
+  lstatSync,
+  renameSync,
+  readdirSync,
+  unlinkSync,
+  rmdirSync,
+  writeFileSync,
+  mkdirSync as _mkdirSync,
+  readFileSync,
+  copyFileSync
+} from "node:fs";
+import { cleanJson } from "@impactor/javascript";
+function resolve(...paths) {
+  let stringPaths = paths.filter(Boolean).map((path) => path instanceof URL ? path.pathname : path.toString());
+  return _resolve(normalize(join(...stringPaths)));
+}
+function parsePath(path) {
+  path = path.toString();
+  let extension = getExtensionSync(path);
+  return {
+    type: isDirSync(path) ? "dir" : "file",
+    // path of the containing dir
+    dir: dirname(path),
+    // basename (file or folder name) without extension
+    name: basename(path, `.${extension}`),
+    extension
+  };
+}
+function getExtensionSync(file) {
+  return extname(file.toString()).toLowerCase().replace(/^\./, "");
+}
+function getSizeSync(path, unit = "b", filter) {
+  let units = { b: 0, kb: 1, mb: 2, gb: 3 };
+  let sizes = recursiveSync(
+    path,
+    (_path, type) => type === "file" ? lstatSync(_path).size / 1024 ** units[unit] : void 0,
+    filter
+  );
+  let sum = (sizes2) => {
+    let total = 0;
+    for (let size of sizes2) {
+      total += Array.isArray(size) ? sum(size) : size;
+    }
+    return total;
+  };
+  return Array.isArray(sizes) ? sum(sizes) : sizes;
+}
+function isDirSync(path) {
+  path = resolve(path);
+  return existsSync(path) && lstatSync(path).isDirectory();
+}
+function getModifiedTimeSync(path) {
+  return lstatSync(resolve(path)).mtimeMs;
+}
+function mkdirSync(path, mode = 511) {
+  if (Array.isArray(path)) {
+    return path.forEach((p) => {
+      mkdirSync(p, mode);
+    });
+  }
+  let options = { mode, recursive: true };
+  if (!existsSync(path)) {
+    _mkdirSync(path, options);
+  }
+}
+var MoveOptionsExisting = /* @__PURE__ */ ((MoveOptionsExisting2) => {
+  MoveOptionsExisting2[MoveOptionsExisting2["replace"] = 0] = "replace";
+  MoveOptionsExisting2[MoveOptionsExisting2["rename"] = 1] = "rename";
+  MoveOptionsExisting2[MoveOptionsExisting2["skip"] = 2] = "skip";
+  MoveOptionsExisting2[MoveOptionsExisting2["stop"] = 3] = "stop";
+  MoveOptionsExisting2[MoveOptionsExisting2["throw"] = 4] = "throw";
+  return MoveOptionsExisting2;
+})(MoveOptionsExisting || {});
+function moveSync(path, newPath, _options) {
+  return renameSync(path, newPath);
+}
+function removeSync(path, filter, keepDir = false) {
+  return recursiveSync(
+    path,
+    (file, type) => type === "file" ? unlinkSync(file) : keepDir ? void 0 : rmdirSync(file),
+    filter
+  );
+}
+function copySync(source, destination, filter = () => true) {
+  source = resolve(source);
+  destination = resolve(destination);
+  return recursiveSync(source, (path, type) => {
+    if (type === "file" && filter(path)) {
+      let destination_ = path.replace(source.toString(), destination);
+      mkdirSync(dirname(destination_));
+      copyFileSync(path, destination_);
+    }
+  });
+}
+function writeSync(path, data, options) {
+  path = resolve(path);
+  mkdirSync(dirname(path));
+  let dataString = ["array", "object"].includes(objectType(data)) ? JSON.stringify(data, null, 2) : data;
+  return writeFileSync(path, dataString, options);
+}
+function readSync(path, options) {
+  path = resolve(path);
+  let opts = {
+    encoding: null,
+    flag: "r",
+    maxAge: 0,
+    ...typeof options === "string" ? { encoding: options } : options
+  };
+  if (opts.maxAge && opts.maxAge > 0 && getModifiedTimeSync(path) + opts.maxAge * 1e3 < Date.now()) {
+    throw new Error(`[fs-sync] expired file ${path}`);
+  }
+  let data = readFileSync(path, {
+    encoding: opts.encoding,
+    flag: opts.flag
+  });
+  if (opts.encoding === void 0) {
+    return data;
+  }
+  data = data.toString();
+  return path.toString().trim().slice(-5) === ".json" ? JSON.parse(cleanJson(data)) : data;
+}
+function stripComments(content) {
+  return content.replaceAll(/(\/\/|#).*|\/\*(.|\n)*\*\//g, "");
+}
+function getEntriesSync(dir = ".", filter, depth, skip) {
+  if (Array.isArray(dir)) {
+    return dir.flatMap((el) => getEntriesSync(el, filter, depth));
+  }
+  dir = resolve(dir);
+  let filterFunction = filter === "files" ? (entry) => lstatSync(entry).isFile() : filter === "dirs" ? (entry) => lstatSync(entry).isDirectory() : filter instanceof RegExp ? (entry) => filter.test(entry) : typeof filter === "function" ? filter : void 0;
+  let skipFunction = skip instanceof RegExp ? (entry) => skip.test(entry) : typeof skip === "function" ? skip : (entry) => ["node_modules", "dist"].includes(entry);
+  let entries = readdirSync(dir);
+  let result = [];
+  for (let entry of entries) {
+    let fullPath = join(dir, entry);
+    if (!filterFunction || filterFunction?.(fullPath)) {
+      result.push(fullPath);
+    }
+    if ((depth === void 0 || depth > 0) && lstatSync(fullPath).isDirectory() && !skipFunction?.(entry)) {
+      let subEntries = getEntriesSync(
+        fullPath,
+        filterFunction,
+        depth === void 0 ? void 0 : depth - 1
+      );
+      result = [...result, ...subEntries];
+    }
+  }
+  return result;
+}
+function recursiveSync(path, apply, filter = () => true) {
+  if (!path) {
+    throw new Error("path not provided");
+  }
+  if (Array.isArray(path)) {
+    return path.map((p) => recursiveSync(p, apply, filter));
+  }
+  path = resolve(path.toString());
+  if (!existsSync(path)) {
+    return;
+  }
+  let result = [];
+  if (isDirSync(path)) {
+    if (filter(path, "dir")) {
+      readdirSync(path).forEach((file) => {
+        result.push(recursiveSync(`${path}/${file}`, apply, filter));
+      });
+      apply(path, "dir");
+    }
+  } else if (filter(path, "file")) {
+    return apply(path, "file");
+  }
+  return result;
+}
+function toPosix(path, removeDriverLetter = true) {
+  let newPath = path.toString().replaceAll("\\", "/");
+  return removeDriverLetter ? newPath.replace(/^[A-Za-z]:/, "") : newPath;
+}
+function validFilePath(path) {
+  let pathResolved = resolve(path), driverLetter = pathResolved.match(/^[A-Za-z]:/)?.[0] || "", filePath = pathResolved.split(/^[A-Za-z]:/)?.[1] || pathResolved;
+  return driverLetter + filePath.split(sep).map((part) => encodeURIComponent(part.trim())).join(sep);
+}
+export {
+  MoveOptionsExisting,
+  copySync,
+  getEntriesSync,
+  getExtensionSync,
+  getModifiedTimeSync,
+  getSizeSync,
+  isDirSync,
+  mkdirSync,
+  moveSync,
+  parsePath,
+  readSync,
+  recursiveSync,
+  removeSync,
+  resolve,
+  stripComments,
+  toPosix,
+  validFilePath,
+  writeSync
+};

package/src/fs-sync.spec.js

@@ -0,0 +1,262 @@
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+import {
+  copySync,
+  getEntriesSync,
+  getExtensionSync,
+  getModifiedTimeSync,
+  getSizeSync,
+  isDirSync,
+  mkdirSync,
+  moveSync,
+  parsePath,
+  readSync,
+  removeSync,
+  resolve,
+  writeSync
+} from "./fs-sync";
+import { objectType } from "@impactor/javascript";
+import { existsSync, readFileSync, utimesSync } from "node:fs";
+import { platform } from "node:process";
+let dir = resolve(import.meta.dirname, "./test!!/fs-sync"), file = dir + "/file.txt";
+beforeEach(() => {
+  removeSync(dir);
+  writeSync(file, "ok");
+});
+afterEach(() => removeSync(dir));
+test("mkdir", () => {
+  expect(existsSync(`${dir}/mkdir`)).toBeFalsy();
+  mkdirSync(`${dir}/mkdir`);
+  expect(existsSync(`${dir}/mkdir`)).toBeTruthy();
+});
+test("write", () => {
+  mkdirSync(dir);
+  expect(existsSync(`${dir}/write.txt`)).toBeFalsy();
+  writeSync(`${dir}/write.txt`, "ok");
+  expect(existsSync(`${dir}/write.txt`)).toBeTruthy();
+  expect(readFileSync(`${dir}/write.txt`).toString()).toEqual("ok");
+});
+test("write in non-existing dir", () => {
+  let file2 = dir + "/non-existing/file.txt";
+  expect(existsSync(file2)).toBeFalsy();
+  writeSync(file2, "ok");
+  expect(existsSync(file2)).toBeTruthy();
+  expect(readFileSync(file2).toString()).toEqual("ok");
+});
+test("resolve", () => {
+  try {
+    expect(resolve("/path", "to/file.js")).toEqual("/path/to/file.js");
+  } catch {
+    expect(resolve("/path", "to/file.js")).toContain(
+      String.raw`path\to\file.js`
+    );
+  }
+});
+test("parsePath", () => {
+  expect(parsePath("/path/to/file.js")).toEqual({
+    type: "file",
+    dir: "/path/to",
+    name: "file",
+    extension: "js"
+  });
+  if (platform === "win32") {
+    expect(parsePath(String.raw`\path\to\file.js`)).toEqual({
+      type: "file",
+      dir: String.raw`\path\to`,
+      name: "file",
+      extension: "js"
+    });
+  }
+});
+test("getExtension", () => {
+  expect(getExtensionSync("/path/to/file.js")).toEqual("js");
+  expect(getExtensionSync(".gitignore")).toEqual("");
+  expect(getExtensionSync("/path/to/.gitignore")).toEqual("");
+  expect(getExtensionSync("/path/to")).toEqual("");
+});
+test("size units", () => {
+  let size = 1234567890, units = { b: 0, kb: 1, mb: 2, gb: 3 };
+  expect(size / 1024 ** units.mb).toBeCloseTo(1177.3, 0);
+});
+test("getSize", () => {
+  writeSync(`${dir}/get-size/file1.txt`, "ok");
+  writeSync(`${dir}/get-size/file2.txt`, "ok");
+  expect(getSizeSync(`${dir}/get-size/file1.txt`)).toEqual(2);
+  expect(getSizeSync(`${dir}/get-size`)).toEqual(4);
+  expect(
+    getSizeSync([`${dir}/get-size/file1.txt`, `${dir}/get-size/file2.txt`])
+  ).toEqual(4);
+});
+test("isDir", () => {
+  expect(isDirSync(file)).toEqual(false);
+  expect(isDirSync(dir)).toEqual(true);
+});
+test("getModifiedTime", () => {
+  expect(Math.floor(getModifiedTimeSync(file))).toBeGreaterThanOrEqual(
+    1624906832178
+  );
+  expect(Math.floor(getModifiedTimeSync(dir))).toBeGreaterThanOrEqual(
+    1624906832178
+  );
+});
+test("move", () => {
+  let file2 = dir + "/file2.txt";
+  expect(existsSync(file)).toBeTruthy();
+  expect(existsSync(file2)).toBeFalsy();
+  moveSync(file, file2);
+  expect(existsSync(file)).toBeFalsy();
+  expect(existsSync(file2)).toBeTruthy();
+});
+test("read", () => {
+  let fileJson = dir + "/file.json", fileArray = dir + "/array.json", fileJsonComments = dir + "/comments.json";
+  writeSync(fileJson, { x: 1, y: 2 });
+  writeSync(fileArray, [1, 2, 3]);
+  writeSync(
+    fileJsonComments,
+    `// this file is created to test reading .json files that contains comments
+      // to test stripComments()
+ 
+   {
+     /* it should remove all comments */
+     /* even this 
+          multi-line comment 
+       */
+     // also this comment
+ 
+     "x": 1,
+     "hello": "ok"
+   }
+   `
+  );
+  let txt = readSync(file), json = readSync(fileJson), jsonWithComments = readSync(fileJsonComments), array = readSync(fileArray);
+  expect(txt.length).toEqual(2);
+  expect(txt).toContain("ok");
+  expect(objectType(txt)).toEqual("string");
+  expect(objectType(json)).toEqual("object");
+  expect(objectType(jsonWithComments)).toEqual("object");
+  expect(objectType(array)).toEqual("array");
+  expect(json).toEqual({ x: 1, y: 2 });
+  expect(jsonWithComments).toEqual({ x: 1, hello: "ok" });
+  expect(array).toEqual([1, 2, 3]);
+});
+test("read from a non-existing file", () => {
+  expect(
+    () => readSync(`${dir}/non-existing.txt`, { maxAge: 24 * 60 * 60 })
+  ).toThrow("no such file or directory");
+});
+test("read: maxAge", () => {
+  let file2 = dir + "/file.txt";
+  writeSync(file2, "ok");
+  expect(readSync(file2, { maxAge: 24 * 60 * 60 })).toEqual("ok");
+});
+test("read from an expired cache", () => {
+  let file2 = dir + "/file.txt";
+  writeSync(file2, "ok");
+  let date = /* @__PURE__ */ new Date(), today = date.getDate();
+  date.setDate(today - 1);
+  let yesterday = date.getTime() / 1e3;
+  utimesSync(file2, yesterday, yesterday);
+  expect(() => readSync(file2, { maxAge: 1 })).toThrow("expired file");
+});
+test("remove dir", () => {
+  expect(existsSync(file)).toBeTruthy();
+  expect(existsSync(dir)).toBeTruthy();
+  removeSync(dir);
+  expect(existsSync(file)).toBeFalsy();
+  expect(existsSync(dir)).toBeFalsy();
+});
+test("remove non-exists path", () => {
+  let file2 = `${dir}/non-existing/file.txt`;
+  removeSync(file2);
+  expect(existsSync(file2)).toBeFalsy();
+});
+test("copy a directory and its sub-directories", () => {
+  writeSync(`${dir}/copy-dir/file.txt`, "");
+  writeSync(`${dir}/copy-dir/sub-dir/file2.txt`, "");
+  copySync(`${dir}/copy-dir`, `${dir}/copy-dir2`);
+  expect(existsSync(`${dir}/copy-dir2/file.txt`)).toBeTruthy();
+  expect(existsSync(`${dir}/copy-dir2/sub-dir/file2.txt`)).toBeTruthy();
+});
+describe("getEntries", () => {
+  let entries = ["file.txt", "file.js"];
+  beforeEach(() => {
+    for (let element of entries) {
+      writeSync(`${dir}/${element}`, "");
+      writeSync(`${dir}/subdir/${element}`, "");
+    }
+  });
+  test("list all entries recursively", () => {
+    expect(getEntriesSync(dir).sort()).toEqual(
+      // all files in dir with full path
+      [
+        ...entries.map((element) => resolve(`${dir}/${element}`)).concat(
+          entries.map((element) => resolve(`${dir}/subdir/${element}`))
+        ),
+        resolve(`${dir}/subdir`)
+      ].sort()
+    );
+  });
+  test("filter by function", () => {
+    expect(getEntriesSync(dir, (element) => element.includes(".js"))).toEqual([
+      resolve(`${dir}/file.js`),
+      resolve(`${dir}/subdir/file.js`)
+    ]);
+  });
+  test("filter by regex", () => {
+    expect(getEntriesSync(dir, /subdir/).sort()).toEqual(
+      [
+        ...entries.map((element) => resolve(`${dir}/subdir/${element}`)),
+        resolve(`${dir}/subdir`)
+      ].sort()
+    );
+  });
+  test("filter by type: files", () => {
+    expect(getEntriesSync(dir, "files").sort()).toEqual(
+      entries.map((element) => resolve(`${dir}/${element}`)).concat(entries.map((element) => resolve(`${dir}/subdir/${element}`))).sort()
+    );
+  });
+  test("filter by type: dirs", () => {
+    expect(getEntriesSync(dir, "dirs")).toEqual([resolve(`${dir}/subdir`)]);
+  });
+  test("depth=0", () => {
+    for (let element of entries) {
+      writeSync(`${dir}/subdir/extra/${element}`, "");
+    }
+    expect(getEntriesSync(dir, void 0, 0).sort()).toEqual(
+      [
+        ...entries.map((element) => resolve(`${dir}/${element}`)),
+        resolve(`${dir}/subdir`)
+      ].sort()
+    );
+  });
+  test("depth=1", () => {
+    for (let element of entries) {
+      writeSync(`${dir}/subdir/extra/${element}`, "");
+    }
+    expect(getEntriesSync(dir, void 0, 1).sort()).toEqual(
+      [
+        ...entries.map((element) => resolve(`${dir}/${element}`)),
+        resolve(`${dir}/subdir`),
+        resolve(`${dir}/subdir/extra`)
+      ].concat(entries.map((element) => resolve(`${dir}/subdir/${element}`))).sort()
+    );
+  });
+  test("depth=2", () => {
+    for (let element of entries) {
+      writeSync(`${dir}/subdir/extra/${element}`, "");
+    }
+    expect(getEntriesSync(dir, void 0, 2).sort()).toEqual(
+      [
+        ...entries.map((element) => resolve(`${dir}/${element}`)),
+        resolve(`${dir}/subdir`),
+        resolve(`${dir}/subdir/extra`)
+      ].concat(entries.map((element) => resolve(`${dir}/subdir/${element}`))).concat(
+        entries.map((element) => resolve(`${dir}/subdir/extra/${element}`))
+      ).sort()
+    );
+  });
+  test("non existing dir", () => {
+    expect(() => getEntriesSync(dir + "/non-existing")).toThrow(
+      "no such file or directory"
+    );
+  });
+});

package/src/fs.d.ts

@@ -0,0 +1,16 @@
+import { type PathLike, type WriteFileOptions } from 'node:fs';
+import { type Abortable } from 'node:events';
+import { type Filter, type MoveOptions, type ReadOptions } from './fs-sync';
+import { type Obj } from '@impactor/javascript';
+export declare function getSize(path: PathLike | PathLike[], unit?: 'b' | 'kb' | 'mb' | 'gb', filter?: Filter): Promise<number>;
+export declare function isDir(path: PathLike): Promise<boolean>;
+export declare function getModifiedTime(file: PathLike): Promise<number>;
+export declare function mkdir(path: PathLike | PathLike[], mode?: number | string): Promise<void>;
+export declare function move(path: PathLike, newPath: PathLike, _options?: MoveOptions): Promise<void>;
+export declare function remove(path: PathLike | PathLike[], filter?: Filter, keepDir?: boolean): Promise<void>;
+export declare function copy(source: PathLike, destination: string, filter?: Filter): Promise<any>;
+export declare function write(path: PathLike, data: any, options?: WriteFileOptions & Abortable): Promise<void>;
+export declare function read<T extends Buffer | string | Array<any> | Obj>(path: PathLike | URL, options?: ReadOptions | BufferEncoding): Promise<T>;
+export declare function getEntries(dir?: string | string[], filter?: ((entry: string) => boolean) | RegExp | 'files' | 'dirs', depth?: number, skip?: ((entry: string) => boolean) | RegExp): Promise<Array<string>>;
+export declare function recursive(path: PathLike | PathLike[], apply: (path: string, type: 'dir' | 'file') => any, filter?: Filter): Promise<any | any[]>;
+export declare function exists(path: PathLike): Promise<boolean>;

package/src/fs.js

@@ -0,0 +1,188 @@
+import {
+  constants,
+  lstatSync,
+  readdirSync
+} from "node:fs";
+import {
+  mkdir as _mkdir,
+  access,
+  copyFile,
+  lstat,
+  readFile,
+  readdir,
+  rename,
+  rmdir,
+  unlink,
+  writeFile
+} from "node:fs/promises";
+import {
+  resolve
+} from "./fs-sync";
+import { dirname, join } from "node:path";
+import { objectType } from "@impactor/javascript";
+import { cleanJson } from "@impactor/javascript";
+function getSize(path, unit = "b", filter) {
+  let units = { b: 0, kb: 1, mb: 2, gb: 3 };
+  return recursive(
+    path,
+    (_path, type) => type === "file" ? lstat(_path).then((stats) => stats.size / 1024 ** units[unit]) : (
+      // todo: for dirs, size = total sizes of its contents
+      void 0
+    ),
+    filter
+  ).then((sizes) => {
+    let sum = (sizes2) => {
+      let total = 0;
+      for (let size of sizes2.filter(Boolean)) {
+        total += Array.isArray(size) ? sum(size) : size;
+      }
+      return total;
+    };
+    return Array.isArray(sizes) ? sum(sizes) : sizes;
+  });
+}
+function isDir(path) {
+  return lstat(path).then((stats) => stats.isDirectory());
+}
+function getModifiedTime(file) {
+  return lstat(file).then((stats) => stats.mtimeMs);
+}
+function mkdir(path, mode = 511) {
+  if (Array.isArray(path)) {
+    return Promise.all(
+      path.map((p) => ({ [p.toString()]: mkdir(p, mode) }))
+    ).then(() => {
+    });
+  }
+  let options = { mode, recursive: true };
+  return access(path, constants.R_OK).catch(() => _mkdir(path, options)).then(() => {
+  });
+}
+async function move(path, newPath, _options) {
+  await mkdir(dirname(newPath.toString()));
+  return rename(path, newPath);
+}
+function remove(path, filter, keepDir = false) {
+  return recursive(
+    path,
+    (file, type) => type === "file" ? unlink(file) : keepDir ? void 0 : rmdir(file),
+    filter
+  );
+}
+function copy(source, destination, filter = () => true) {
+  source = resolve(source);
+  destination = resolve(destination);
+  return recursive(
+    source,
+    (path, type) => {
+      path = path.toString();
+      if (type === "file" && filter(path)) {
+        let destination_ = path.replace(source.toString(), destination);
+        return mkdir(dirname(destination_)).then(
+          () => copyFile(path, destination_)
+        );
+      }
+      return;
+    },
+    filter
+  );
+}
+function write(path, data, options) {
+  path = resolve(path);
+  return mkdir(dirname(path)).then(
+    () => ["array", "object"].includes(objectType(data)) ? JSON.stringify(data, null, 2) : data
+  ).then((dataString) => writeFile(path, dataString, options));
+}
+function read(path, options) {
+  path = resolve(path);
+  let opts = {
+    encoding: null,
+    flag: "r",
+    maxAge: 0,
+    ...typeof options === "string" ? { encoding: options } : options
+  };
+  return getModifiedTime(path).then((modified) => {
+    if (opts.maxAge && opts.maxAge > 0 && modified + opts.maxAge < Date.now()) {
+      throw new Error(`[fs-sync] expired file ${path}`);
+    }
+    return readFile(path, {
+      encoding: opts.encoding,
+      flag: opts.flag
+    }).then((data) => {
+      if (opts.encoding === void 0) {
+        return data;
+      }
+      data = data.toString();
+      return path.toString().trim().slice(-5) === ".json" ? JSON.parse(cleanJson(data)) : data;
+    });
+  });
+}
+async function getEntries(dir = ".", filter, depth, skip) {
+  if (Array.isArray(dir)) {
+    return Promise.all(dir.map((el) => getEntries(el, filter, depth))).then(
+      // combine an array of arrays into a single array
+      (result2) => result2.flat()
+    );
+  }
+  dir = resolve(dir);
+  let filterFunction = filter === "files" ? (entry) => lstatSync(entry).isFile() : filter === "dirs" ? (entry) => lstatSync(entry).isDirectory() : filter instanceof RegExp ? (entry) => filter.test(entry) : typeof filter === "function" ? filter : void 0;
+  let skipFunction = skip instanceof RegExp ? (entry) => skip.test(entry) : typeof skip === "function" ? skip : (entry) => ["node_modules", "dist"].includes(entry);
+  let entries = readdirSync(dir);
+  let result = [];
+  for (let entry of entries) {
+    let path = join(dir, entry), _fullPath = resolve(dir, entry);
+    if (!filterFunction || filterFunction(path)) {
+      result.push(path);
+    }
+    if ((depth === void 0 || depth > 0) && lstatSync(path).isDirectory() && !skipFunction?.(entry)) {
+      let subEntries = await getEntries(
+        path,
+        filterFunction,
+        depth === void 0 ? void 0 : depth - 1
+      );
+      result = result.concat(subEntries);
+    }
+  }
+  return result;
+}
+async function recursive(path, apply, filter) {
+  if (!path) {
+    throw "path not provided";
+  }
+  if (Array.isArray(path)) {
+    return Promise.all(
+      // todo: path.map((p) => ({ [p]: recursive(p as string, apply) }))
+      path.map((p) => recursive(p, apply, filter))
+    );
+  }
+  let _path = resolve(path);
+  await access(_path, constants.R_OK);
+  let _isDir = await isDir(_path);
+  if (filter?.(_path, _isDir ? "dir" : "file") === false) return;
+  if (_isDir) {
+    apply(_path, "dir");
+    let dir = await readdir(_path);
+    for (let file of dir) {
+      await recursive(`${_path}/${file}`, apply, filter);
+    }
+  } else {
+    apply(_path, "file");
+  }
+}
+function exists(path) {
+  return access(resolve(path), constants.R_OK).then(() => true).catch(() => false);
+}
+export {
+  copy,
+  exists,
+  getEntries,
+  getModifiedTime,
+  getSize,
+  isDir,
+  mkdir,
+  move,
+  read,
+  recursive,
+  remove,
+  write
+};