@reliverse/relifso 1.2.0 → 1.2.1

package/bin/impl/copy.d.ts

@@ -18,3 +18,11 @@ export interface CopyOptions {
  * @param options - Options for the copy operation.
  */
 export declare function copySync(src: string, dest: string, options?: CopyOptions): void;
+/**
+ * Asynchronously copies a file or directory. The directory can have contents. Like `cp -r`.
+ *
+ * @param src - The source path.
+ * @param dest - The destination path.
+ * @param options - Options for the copy operation.
+ */
+export declare function copy(src: string, dest: string, options?: CopyOptions): Promise<void>;

package/bin/impl/copy.js

@@ -1,6 +1,8 @@
 import { copyFileSync, statSync, constants as fsConstants } from "node:fs";
+import { stat as statAsync, copyFile as copyFileAsync, constants as fsConstantsAsync } from "node:fs/promises";
 import { dirname, join as joinPath, basename as basenamePath } from "node:path";
 import { mkdirsSync } from "./mkdirs.js";
+import { mkdirs } from "./mkdirs.js";
 export function copySync(src, dest, options = {}) {
   const { overwrite = options.clobber || false, preserveTimestamps = false } = options;
   const srcStat = statSync(src, { throwIfNoEntry: true });
@@ -26,3 +28,37 @@ export function copySync(src, dest, options = {}) {
     }
   }
 }
+export async function copy(src, dest, options = {}) {
+  const { overwrite = options.clobber || false, preserveTimestamps = false } = options;
+  const srcStat = await statAsync(src).catch((e) => {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  });
+  if (!srcStat) {
+  }
+  let destFinal = dest;
+  const destStat = await statAsync(dest).catch((e) => {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  });
+  if (destStat?.isDirectory()) {
+    destFinal = joinPath(dest, basenamePath(src));
+  }
+  const destExists = await statAsync(destFinal).catch((e) => {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  });
+  if (destExists && !overwrite) {
+    throw new Error(`Destination ${destFinal} already exists and overwrite is false.`);
+  }
+  const destDir = dirname(destFinal);
+  await mkdirs(destDir);
+  if (srcStat?.isDirectory()) {
+    await mkdirs(destFinal);
+  } else {
+    await copyFileAsync(src, destFinal, preserveTimestamps ? fsConstantsAsync.COPYFILE_FICLONE : 0);
+    if (preserveTimestamps) {
+      console.warn("preserveTimestamps: utimes is not implemented for the moment.");
+    }
+  }
+}

package/bin/impl/create-file.d.ts

@@ -1 +1,2 @@
 export declare function createFileSync(file: string, content?: string): void;
+export declare function createFile(file: string, content?: string): Promise<void>;

package/bin/impl/create-file.js

@@ -1,8 +1,21 @@
 import { existsSync } from "node:fs";
+import { stat } from "node:fs/promises";
 import { writeFileSync } from "./write-file.js";
+import { writeFile } from "./write-file.js";
 export function createFileSync(file, content = "") {
   if (existsSync(file)) {
     return;
   }
   return writeFileSync(file, content);
 }
+export async function createFile(file, content = "") {
+  try {
+    await stat(file);
+    return;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return writeFile(file, content);
+    }
+    throw error;
+  }
+}

package/bin/impl/empty-dir.d.ts

@@ -1 +1,2 @@
 export declare function emptyDirSync(dir: string): void;
+export declare function emptyDir(dir: string): Promise<void>;

package/bin/impl/empty-dir.js

@@ -1,4 +1,5 @@
 import { existsSync, readdirSync, rmSync } from "node:fs";
+import { readdir, rm, stat } from "node:fs/promises";
 import path from "node:path";
 export function emptyDirSync(dir) {
   if (!existsSync(dir)) {
@@ -8,3 +9,16 @@ export function emptyDirSync(dir) {
     rmSync(path.resolve(dir, file), { recursive: true, force: true });
   }
 }
+export async function emptyDir(dir) {
+  try {
+    await stat(dir);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  for (const file of await readdir(dir)) {
+    await rm(path.resolve(dir, file), { recursive: true, force: true });
+  }
+}

package/bin/impl/mkdirs.d.ts

@@ -1 +1,2 @@
 export declare function mkdirsSync(dir: string): string | undefined;
+export declare function mkdirs(dir: string): Promise<string | undefined>;

package/bin/impl/mkdirs.js

@@ -1,7 +1,19 @@
 import { mkdirSync, existsSync } from "node:fs";
+import { mkdir, stat } from "node:fs/promises";
 export function mkdirsSync(dir) {
   if (existsSync(dir)) {
     return;
   }
   return mkdirSync(dir, { recursive: true });
 }
+export async function mkdirs(dir) {
+  try {
+    await stat(dir);
+    return void 0;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return mkdir(dir, { recursive: true });
+    }
+    throw error;
+  }
+}

package/bin/impl/move.d.ts

@@ -12,3 +12,4 @@ export interface MoveOptions {
  * @param options - Options for the move operation.
  */
 export declare function moveSync(src: string, dest: string, options?: MoveOptions): void;
+export declare function move(src: string, dest: string, options?: MoveOptions): Promise<void>;

package/bin/impl/move.js

@@ -1,6 +1,8 @@
 import { renameSync, statSync, unlinkSync, copyFileSync } from "node:fs";
+import { rename, stat, unlink, copyFile } from "node:fs/promises";
 import { dirname, basename, join as joinPath } from "node:path";
 import { mkdirsSync } from "./mkdirs.js";
+import { mkdirs } from "./mkdirs.js";
 export function moveSync(src, dest, options = {}) {
   let overwrite;
   if (options.overwrite !== void 0) {
@@ -40,3 +42,52 @@ export function moveSync(src, dest, options = {}) {
     }
   }
 }
+export async function move(src, dest, options = {}) {
+  let overwrite;
+  if (options.overwrite !== void 0) {
+    overwrite = options.overwrite;
+  } else if (options.clobber !== void 0) {
+    console.warn(
+      "Warning: The 'clobber' option in move is deprecated and will be removed in a future version. Please use 'overwrite' instead."
+    );
+    overwrite = options.clobber;
+  } else {
+    overwrite = false;
+  }
+  const srcStat = await stat(src).catch((e) => {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  });
+  if (!srcStat) {
+  }
+  let destFinal = dest;
+  const destStat = await stat(dest).catch((e) => {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  });
+  if (destStat?.isDirectory()) {
+    destFinal = joinPath(dest, basename(src));
+  }
+  const destFinalStat = await stat(destFinal).catch((e) => {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  });
+  if (destFinalStat && !overwrite) {
+    throw new Error(`Destination ${destFinal} already exists and overwrite is false.`);
+  }
+  const destDir = dirname(destFinal);
+  await mkdirs(destDir);
+  try {
+    await rename(src, destFinal);
+  } catch (err) {
+    if (err.code === "EXDEV") {
+      await copyFile(src, destFinal);
+      await unlink(src);
+    } else if (err.code === "EISDIR" || err.code === "EPERM") {
+      await copyFile(src, destFinal);
+      await unlink(src);
+    } else {
+      throw err;
+    }
+  }
+}

package/bin/impl/output-file.d.ts

@@ -6,3 +6,11 @@
  * @param options - Options for writing the file (e.g., encoding, mode, flag).
  */
 export declare function outputFileSync(file: string, data: string | Uint8Array, options?: unknown): void;
+/**
+ * Ensures that the directory for the file exists and then asynchronously writes the data to the file.
+ *
+ * @param file - The path to the file.
+ * @param data - The data to write.
+ * @param options - Options for writing the file (e.g., encoding, mode, flag).
+ */
+export declare function outputFile(file: string, data: string | Uint8Array, options?: unknown): Promise<void>;

package/bin/impl/output-file.js

@@ -1,8 +1,15 @@
 import { dirname } from "node:path";
 import { mkdirsSync } from "./mkdirs.js";
+import { mkdirs } from "./mkdirs.js";
 import { writeFileSync } from "./write-file.js";
+import { writeFile } from "./write-file.js";
 export function outputFileSync(file, data, options) {
   const dir = dirname(file);
   mkdirsSync(dir);
   writeFileSync(file, data, options);
 }
+export async function outputFile(file, data, options) {
+  const dir = dirname(file);
+  await mkdirs(dir);
+  await writeFile(file, data, options);
+}

package/bin/impl/output-json.d.ts

@@ -6,3 +6,11 @@
  * @param options - Options for writing the JSON file (e.g., replacer, space).
  */
 export declare function outputJsonSync(file: string, data: unknown, options?: unknown): void;
+/**
+ * Ensures that the directory for the JSON file exists and then asynchronously writes the JSON data to the file.
+ *
+ * @param file - The path to the file.
+ * @param data - The JSON data to write.
+ * @param options - Options for writing the JSON file (e.g., replacer, space).
+ */
+export declare function outputJson(file: string, data: unknown, options?: unknown): Promise<void>;

package/bin/impl/output-json.js

@@ -1,8 +1,15 @@
 import { dirname } from "node:path";
 import { mkdirsSync } from "./mkdirs.js";
+import { mkdirs } from "./mkdirs.js";
 import { writeJsonSync } from "./write-json.js";
+import { writeJson } from "./write-json.js";
 export function outputJsonSync(file, data, options) {
   const dir = dirname(file);
   mkdirsSync(dir);
   writeJsonSync(file, data, options);
 }
+export async function outputJson(file, data, options) {
+  const dir = dirname(file);
+  await mkdirs(dir);
+  await writeJson(file, data, options);
+}

package/bin/impl/path-exists.d.ts

@@ -1 +1,2 @@
 export declare function pathExistsSync(path: string): boolean;
+export declare function pathExists(path: string): Promise<boolean>;

package/bin/impl/path-exists.js

@@ -1,4 +1,16 @@
 import { existsSync } from "node:fs";
+import { stat } from "node:fs/promises";
 export function pathExistsSync(path) {
   return existsSync(path);
 }
+export async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}

package/bin/impl/read-file.d.ts

@@ -9,4 +9,22 @@ export interface ReadFileOptions {
  * @param options - Options for reading the file. Can be an encoding string or an object.
  * @returns The file content as a string or Buffer.
  */
-export declare function readFileSync(path: string, options?: BufferEncoding | ReadFileOptions): string | Buffer;
+export declare function readFileSync(path: string, options: BufferEncoding | (ReadFileOptions & {
+    encoding: BufferEncoding;
+})): string;
+export declare function readFileSync(path: string, options?: (ReadFileOptions & {
+    encoding?: null;
+}) | null): Buffer;
+/**
+ * Asynchronously reads the entire contents of a file.
+ *
+ * @param path - The path to the file.
+ * @param options - Options for reading the file. Can be an encoding string or an object.
+ * @returns A promise that resolves with the file content as a string or Buffer.
+ */
+export declare function readFile(path: string, options: BufferEncoding | (ReadFileOptions & {
+    encoding: BufferEncoding;
+})): Promise<string>;
+export declare function readFile(path: string, options?: (ReadFileOptions & {
+    encoding?: null;
+}) | null): Promise<Buffer>;

package/bin/impl/read-file.js

@@ -1,12 +1,30 @@
 import { readFileSync as nodeReadFileSync } from "node:fs";
+import { readFile as nodeReadFileAsync } from "node:fs/promises";
 export function readFileSync(path, options) {
   let encoding;
   let flag;
   if (typeof options === "string") {
     encoding = options;
   } else if (options) {
-    encoding = options.encoding ?? void 0;
+    encoding = options.encoding;
     flag = options.flag;
   }
-  return nodeReadFileSync(path, { encoding, flag });
+  if (encoding) {
+    return nodeReadFileSync(path, { encoding, flag });
+  }
+  return nodeReadFileSync(path, { encoding: null, flag });
+}
+export async function readFile(path, options) {
+  let encoding;
+  let flag;
+  if (typeof options === "string") {
+    encoding = options;
+  } else if (options) {
+    encoding = options.encoding;
+    flag = options.flag;
+  }
+  if (encoding) {
+    return nodeReadFileAsync(path, { encoding, flag });
+  }
+  return nodeReadFileAsync(path, { encoding: null, flag });
 }

package/bin/impl/read-json.d.ts

@@ -12,3 +12,11 @@ export interface ReadJsonOptions {
  * @returns The parsed JSON object.
  */
 export declare function readJsonSync<T = unknown>(file: string, options?: BufferEncoding | ReadJsonOptions): T;
+/**
+ * Asynchronously reads a JSON file and then parses it into an object.
+ *
+ * @param file - The path to the file.
+ * @param options - Options for reading the file or parsing JSON. Can be an encoding string or an object.
+ * @returns A promise that resolves with the parsed JSON object.
+ */
+export declare function readJson<T = unknown>(file: string, options?: BufferEncoding | ReadJsonOptions): Promise<T>;

package/bin/impl/read-json.js

@@ -1,4 +1,5 @@
 import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 export function readJsonSync(file, options) {
   let encoding = "utf8";
   let reviver;
@@ -22,3 +23,28 @@ export function readJsonSync(file, options) {
     return void 0;
   }
 }
+export async function readJson(file, options) {
+  let encoding = "utf8";
+  let reviver;
+  let throws = true;
+  let flag;
+  if (typeof options === "string") {
+    encoding = options;
+  } else if (options) {
+    encoding = options.encoding ?? encoding;
+    reviver = options.reviver;
+    flag = options.flag;
+    if (options.throws !== void 0) {
+      throws = options.throws;
+    }
+  }
+  try {
+    const data = await readFile(file, { encoding, flag });
+    return JSON.parse(data, reviver);
+  } catch (err) {
+    if (throws) {
+      throw err;
+    }
+    return void 0;
+  }
+}

package/bin/impl/remove.d.ts

@@ -1 +1,2 @@
 export declare function removeSync(path: string): void;
+export declare function remove(path: string): Promise<void>;

package/bin/impl/remove.js

@@ -1,4 +1,8 @@
 import { rmSync } from "node:fs";
+import { rm } from "node:fs/promises";
 export function removeSync(path) {
   return rmSync(path, { recursive: true, force: true });
 }
+export async function remove(path) {
+  return rm(path, { recursive: true, force: true });
+}

package/bin/impl/write-file.d.ts

@@ -9,3 +9,12 @@ export type WriteFileOptions = import("node:fs").WriteFileOptions;
  * @param options - Options for writing the file. Can be an encoding string or an object.
  */
 export declare function writeFileSync(file: PathLike | number, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): void;
+/**
+ * Asynchronously writes data to a file, replacing the file if it already exists.
+ * Ensures the directory exists before writing.
+ *
+ * @param file - Path to the file.
+ * @param data - The data to write. If something other than a Buffer or Uint8Array is provided, it is converted to a string.
+ * @param options - Options for writing the file. Can be an encoding string or an object.
+ */
+export declare function writeFile(file: PathLike | number, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): Promise<void>;

package/bin/impl/write-file.js

@@ -1,4 +1,5 @@
 import { existsSync, mkdirSync, writeFileSync as nodeWriteFileSync } from "node:fs";
+import { mkdir, writeFile as nodeWriteFileAsync, stat } from "node:fs/promises";
 import path from "node:path";
 export function writeFileSync(file, data, options) {
   const dir = path.dirname(file.toString());
@@ -7,3 +8,16 @@ export function writeFileSync(file, data, options) {
   }
   nodeWriteFileSync(file, data, options);
 }
+export async function writeFile(file, data, options) {
+  const dir = path.dirname(file.toString());
+  try {
+    await stat(dir);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      await mkdir(dir, { recursive: true });
+    } else {
+      throw error;
+    }
+  }
+  return nodeWriteFileAsync(file, data, options);
+}

package/bin/impl/write-json.d.ts

@@ -18,3 +18,11 @@ export interface WriteJsonOptions {
  * @param options - Options for stringifying JSON or writing the file.
  */
 export declare function writeJsonSync(file: string, object: unknown, options?: WriteJsonOptions): void;
+/**
+ * Asynchronously writes an object to a JSON file.
+ *
+ * @param file - The path to the file.
+ * @param object - The object to stringify and write.
+ * @param options - Options for stringifying JSON or writing the file.
+ */
+export declare function writeJson(file: string, object: unknown, options?: WriteJsonOptions): Promise<void>;

package/bin/impl/write-json.js

@@ -1,4 +1,5 @@
 import { writeFileSync } from "./write-file.js";
+import { writeFile } from "./write-file.js";
 export function writeJsonSync(file, object, options = {}) {
   const replacer = options.replacer === void 0 ? null : options.replacer;
   const space = options.space === void 0 ? 2 : options.space;
@@ -9,3 +10,13 @@ export function writeJsonSync(file, object, options = {}) {
   const str = JSON.stringify(object, replacer, space);
   writeFileSync(file, str, fileWriteOpts);
 }
+export async function writeJson(file, object, options = {}) {
+  const replacer = options.replacer === void 0 ? null : options.replacer;
+  const space = options.space === void 0 ? 2 : options.space;
+  const fileWriteOpts = {};
+  if (options.encoding !== void 0) fileWriteOpts.encoding = options.encoding;
+  if (options.mode !== void 0) fileWriteOpts.mode = options.mode;
+  if (options.flag !== void 0) fileWriteOpts.flag = options.flag.toString();
+  const str = JSON.stringify(object, replacer, space);
+  await writeFile(file, str, fileWriteOpts);
+}

package/bin/mod.d.ts

@@ -1,47 +1,33 @@
 import type { Stats } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
 import type { DiveOptions } from "./impl/dive.js";
-import { copySync } from "./impl/copy.js";
-import { createFileSync } from "./impl/create-file.js";
+import { copy, copySync } from "./impl/copy.js";
+import { createFile, createFileSync } from "./impl/create-file.js";
 import { diveSync } from "./impl/dive.js";
-import { emptyDirSync } from "./impl/empty-dir.js";
-import { mkdirsSync } from "./impl/mkdirs.js";
-import { moveSync } from "./impl/move.js";
-import { outputFileSync } from "./impl/output-file.js";
-import { outputJsonSync } from "./impl/output-json.js";
-import { pathExistsSync } from "./impl/path-exists.js";
-import { readFileSync } from "./impl/read-file.js";
-import { readJsonSync, type ReadJsonOptions } from "./impl/read-json.js";
-import { removeSync } from "./impl/remove.js";
-import { writeFileSync } from "./impl/write-file.js";
-import { writeJsonSync } from "./impl/write-json.js";
-declare const readJson: <T>(file: string, options?: BufferEncoding | ReadJsonOptions) => Promise<T>;
-declare const writeJson: (file: string, object: unknown, options?: import("./impl/write-json.js").WriteJsonOptions | undefined) => Promise<void>;
-declare const createFile: (file: string, content?: string | undefined) => Promise<void>;
-declare const writeFile: (file: number | import("fs").PathLike, data: string | NodeJS.ArrayBufferView<ArrayBufferLike>, options?: import("fs").WriteFileOptions | undefined) => Promise<void>;
-declare const readFile: (path: string, options?: BufferEncoding | import("./impl/read-file.js").ReadFileOptions | undefined) => Promise<string | Buffer<ArrayBufferLike>>;
-declare const mkdirs: (dir: string) => Promise<string | undefined>;
-declare const emptyDir: (dir: string) => Promise<void>;
-declare const pathExists: (path: string) => Promise<boolean>;
-declare const copy: (src: string, dest: string, options?: import("./impl/copy.js").CopyOptions | undefined) => Promise<void>;
-declare const move: (src: string, dest: string, options?: import("./impl/move.js").MoveOptions | undefined) => Promise<void>;
-declare const remove: (path: string) => Promise<void>;
-declare const outputJson: (file: string, data: unknown, options?: unknown) => Promise<void>;
-declare const outputFile: (file: string, data: string | Uint8Array<ArrayBufferLike>, options?: unknown) => Promise<void>;
+import { emptyDir, emptyDirSync } from "./impl/empty-dir.js";
+import { mkdirs, mkdirsSync } from "./impl/mkdirs.js";
+import { move, moveSync } from "./impl/move.js";
+import { outputFile, outputFileSync } from "./impl/output-file.js";
+import { outputJson, outputJsonSync } from "./impl/output-json.js";
+import { pathExists, pathExistsSync } from "./impl/path-exists.js";
+import { readFile, readFileSync } from "./impl/read-file.js";
+import { readJson, readJsonSync } from "./impl/read-json.js";
+import { remove, removeSync } from "./impl/remove.js";
+import { writeFile, writeFileSync } from "./impl/write-file.js";
+import { writeJson, writeJsonSync } from "./impl/write-json.js";
 export declare function dive(directory: string, action: (file: string, stat: Stats) => void | Promise<void>, options?: DiveOptions): Promise<void>;
 export declare function dive(directory: string, options?: DiveOptions): Promise<string[]>;
-declare const mkdirp: (dir: string) => Promise<string | undefined>;
-declare const ensureDir: (dir: string) => Promise<string | undefined>;
-declare const ensureFile: (file: string, content?: string | undefined) => Promise<void>;
-declare const rimraf: (path: string) => Promise<void>;
-declare const ncp: (src: string, dest: string, options?: import("./impl/copy.js").CopyOptions | undefined) => Promise<void>;
+declare const mkdirp: typeof mkdirs;
+declare const ensureDir: typeof mkdirs;
+declare const ensureFile: typeof createFile;
+declare const rimraf: typeof remove;
+declare const ncp: typeof copy;
 declare const mkdirpSync: typeof mkdirsSync;
 declare const ensureDirSync: typeof mkdirsSync;
 declare const ensureFileSync: typeof createFileSync;
 declare const rimrafSync: typeof removeSync;
 declare const ncpSync: typeof copySync;
-export * from "node:fs";
-export { default } from "node:fs";
-export { readJson, writeJson, createFile, writeFile, readFile, mkdirs, emptyDir, pathExists, copy, move, remove, readJsonSync, writeJsonSync, createFileSync, writeFileSync, readFileSync, mkdirsSync, emptyDirSync, pathExistsSync, copySync, moveSync, removeSync, mkdirp, mkdirpSync, rimraf, rimrafSync, ncp, ncpSync, ensureDir, ensureDirSync, ensureFile, ensureFileSync, outputJson, outputJsonSync, outputFile, outputFileSync, diveSync, };
+export { readJson, writeJson, createFile, writeFile, readFile, mkdirs, emptyDir, pathExists, copy, move, remove, readdir, stat, readJsonSync, writeJsonSync, createFileSync, writeFileSync, readFileSync, mkdirsSync, emptyDirSync, pathExistsSync, copySync, moveSync, removeSync, mkdirp, mkdirpSync, rimraf, rimrafSync, ncp, ncpSync, ensureDir, ensureDirSync, ensureFile, ensureFileSync, outputJson, outputJsonSync, outputFile, outputFileSync, diveSync, };
 export type { CopyOptions } from "./impl/copy.js";
 export type { MoveOptions } from "./impl/move.js";
 export type { ReadFileOptions } from "./impl/read-file.js";

package/bin/mod.js

@@ -1,33 +1,19 @@
-import { readdir, stat } from "node:fs/promises";
+import { readdir as nodeReaddirInternal, stat as nodeStatInternal, readdir, stat } from "node:fs/promises";
 import { join as pathJoin } from "node:path";
-import { toAsync } from "./impl/async.js";
-import { copySync } from "./impl/copy.js";
-import { createFileSync } from "./impl/create-file.js";
+import { copy, copySync } from "./impl/copy.js";
+import { createFile, createFileSync } from "./impl/create-file.js";
 import { diveSync } from "./impl/dive.js";
-import { emptyDirSync } from "./impl/empty-dir.js";
-import { mkdirsSync } from "./impl/mkdirs.js";
-import { moveSync } from "./impl/move.js";
-import { outputFileSync } from "./impl/output-file.js";
-import { outputJsonSync } from "./impl/output-json.js";
-import { pathExistsSync } from "./impl/path-exists.js";
-import { readFileSync } from "./impl/read-file.js";
-import { readJsonSync } from "./impl/read-json.js";
-import { removeSync } from "./impl/remove.js";
-import { writeFileSync } from "./impl/write-file.js";
-import { writeJsonSync } from "./impl/write-json.js";
-const readJson = toAsync(readJsonSync);
-const writeJson = toAsync(writeJsonSync);
-const createFile = toAsync(createFileSync);
-const writeFile = toAsync(writeFileSync);
-const readFile = toAsync(readFileSync);
-const mkdirs = toAsync(mkdirsSync);
-const emptyDir = toAsync(emptyDirSync);
-const pathExists = toAsync(pathExistsSync);
-const copy = toAsync(copySync);
-const move = toAsync(moveSync);
-const remove = toAsync(removeSync);
-const outputJson = toAsync(outputJsonSync);
-const outputFile = toAsync(outputFileSync);
+import { emptyDir, emptyDirSync } from "./impl/empty-dir.js";
+import { mkdirs, mkdirsSync } from "./impl/mkdirs.js";
+import { move, moveSync } from "./impl/move.js";
+import { outputFile, outputFileSync } from "./impl/output-file.js";
+import { outputJson, outputJsonSync } from "./impl/output-json.js";
+import { pathExists, pathExistsSync } from "./impl/path-exists.js";
+import { readFile, readFileSync } from "./impl/read-file.js";
+import { readJson, readJsonSync } from "./impl/read-json.js";
+import { remove, removeSync } from "./impl/remove.js";
+import { writeFile, writeFileSync } from "./impl/write-file.js";
+import { writeJson, writeJsonSync } from "./impl/write-json.js";
 async function* _diveWorker(currentPath, options, currentDepth) {
   const maxDepth = options.depth ?? Number.POSITIVE_INFINITY;
   if (currentDepth > maxDepth) {
@@ -35,7 +21,7 @@ async function* _diveWorker(currentPath, options, currentDepth) {
   }
   let entries;
   try {
-    entries = await readdir(currentPath, { withFileTypes: true });
+    entries = await nodeReaddirInternal(currentPath, { withFileTypes: true });
   } catch (_err) {
     return;
   }
@@ -54,7 +40,7 @@ async function* _diveWorker(currentPath, options, currentDepth) {
     }
     let entryStat;
     try {
-      entryStat = await stat(entryPath);
+      entryStat = await nodeStatInternal(entryPath);
     } catch (_err) {
       continue;
     }
@@ -115,8 +101,6 @@ const ensureDirSync = mkdirsSync;
 const ensureFileSync = createFileSync;
 const rimrafSync = removeSync;
 const ncpSync = copySync;
-export * from "node:fs";
-export { default } from "node:fs";
 export {
   readJson,
   writeJson,
@@ -129,6 +113,8 @@ export {
   copy,
   move,
   remove,
+  readdir,
+  stat,
   readJsonSync,
   writeJsonSync,
   createFileSync,

package/package.json

@@ -1,14 +1,18 @@
 {
   "dependencies": {
+    "@reliverse/relinka": "^1.4.5",
     "fs-extra": "^11.3.0",
-    "jsonfile": "^6.1.0"
+    "jsonfile": "^6.1.0",
+    "magic-string": "^0.30.17",
+    "p-map": "^7.0.3",
+    "zeptomatch": "^2.0.1"
   },
   "description": "@reliverse/relifso is a modern filesystem toolkit for builders. Drop-in replacement for node:fs and fs-extra — powered by native promises, built with ES modules, and packed with DX-focused utilities.",
   "homepage": "https://docs.reliverse.org",
   "license": "MIT",
   "name": "@reliverse/relifso",
   "type": "module",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "keywords": [
     "fs",
     "file",

package/bin/impl/async.d.ts

@@ -1,7 +0,0 @@
-/**
- * Converts a synchronous function into an asynchronous function that returns a Promise.
- *
- * @param fn - The synchronous function to convert.
- * @returns An asynchronous function that wraps the original synchronous function.
- */
-export declare function toAsync<T extends (...args: any[]) => any>(fn: T): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;

package/bin/impl/async.js

@@ -1,9 +0,0 @@
-export function toAsync(fn) {
-  return (...args) => new Promise((resolve, reject) => {
-    try {
-      resolve(fn(...args));
-    } catch (error) {
-      reject(error);
-    }
-  });
-}