@reliverse/relifso 1.3.0 → 1.4.0

package/bin/impl/dive-async.js

@@ -0,0 +1,88 @@
+import { readdir as nodeReaddirInternal, stat as nodeStatInternal } from "node:fs/promises";
+import { join as pathJoin } from "node:path";
+import { isBun, getStatsBun } from "./bun.js";
+async function* _diveWorker(currentPath, options, currentDepth) {
+  const maxDepth = options.depth ?? Number.POSITIVE_INFINITY;
+  if (currentDepth > maxDepth) {
+    return;
+  }
+  let entries;
+  try {
+    entries = await nodeReaddirInternal(currentPath, { withFileTypes: true });
+  } catch (_err) {
+    return;
+  }
+  for (const entry of entries) {
+    const entryPath = pathJoin(currentPath, entry.name);
+    if (!(options.all ?? false) && entry.name.startsWith(".")) {
+      continue;
+    }
+    if (options.ignore) {
+      if (Array.isArray(options.ignore) && options.ignore.some((pattern) => entry.name.includes(pattern))) {
+        continue;
+      }
+      if (options.ignore instanceof RegExp && options.ignore.test(entryPath)) {
+        continue;
+      }
+    }
+    let entryStat;
+    try {
+      if (isBun) {
+        try {
+          entryStat = await getStatsBun(entryPath);
+        } catch (_error) {
+          entryStat = await nodeStatInternal(entryPath);
+        }
+      } else {
+        entryStat = await nodeStatInternal(entryPath);
+      }
+    } catch (_err) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      if (options.directories ?? false) {
+        yield { file: entryPath, stat: entryStat };
+      }
+      if (options.recursive ?? true) {
+        if (currentDepth < maxDepth) {
+          yield* _diveWorker(entryPath, options, currentDepth + 1);
+        }
+      }
+    } else if (entry.isFile()) {
+      if (options.files ?? true) {
+        yield { file: entryPath, stat: entryStat };
+      }
+    }
+  }
+}
+export async function dive(directory, actionOrOptions, optionsOnly) {
+  let action;
+  let options;
+  if (typeof actionOrOptions === "function") {
+    action = actionOrOptions;
+    options = optionsOnly;
+  } else {
+    options = actionOrOptions;
+  }
+  const currentOptions = {
+    recursive: true,
+    files: true,
+    directories: false,
+    all: false,
+    depth: Number.POSITIVE_INFINITY,
+    ...options
+    // User options override defaults
+  };
+  if (action) {
+    for await (const { file, stat: entryStat } of _diveWorker(directory, currentOptions, 0)) {
+      await action(file, entryStat);
+    }
+    return;
+  } else {
+    const results = [];
+    for await (const { file } of _diveWorker(directory, currentOptions, 0)) {
+      results.push(file);
+    }
+    return results;
+  }
+}

package/bin/impl/extras.d.ts

@@ -0,0 +1,15 @@
+import { exec } from "node:child_process";
+export declare const execAsync: typeof exec.__promisify__;
+export declare function setHiddenAttributeOnWindows(folderPath: string): Promise<void>;
+export declare function isHidden(filePath: string): Promise<boolean>;
+/**
+ * Checks if a directory is empty
+ * @param directory Path to the directory
+ * @returns Boolean indicating if the directory is empty
+ */
+export declare function isDirectoryEmpty(directory: string): Promise<boolean>;
+/**
+ * Removes the specified directory if it exists and then ensures it exists.
+ * @param dir - The directory to remove and ensure.
+ */
+export declare function rmEnsureDir(dir: string): Promise<void>;

package/bin/impl/extras.js

@@ -0,0 +1,47 @@
+import { ensuredir } from "@reliverse/relifso";
+import { exec } from "node:child_process";
+import { readdir } from "node:fs/promises";
+import { promisify } from "node:util";
+import { pathExists } from "./path-exists.js";
+import { remove } from "./remove.js";
+export const execAsync = promisify(exec);
+export async function setHiddenAttributeOnWindows(folderPath) {
+  if (process.platform === "win32") {
+    try {
+      if (await pathExists(folderPath)) {
+        const isAlreadyHidden = await isHidden(folderPath);
+        if (!isAlreadyHidden) {
+          await execAsync(`attrib +h "${folderPath}"`);
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to set hidden attribute:", String(error));
+    }
+  }
+}
+export async function isHidden(filePath) {
+  if (process.platform === "win32") {
+    const attributes = await execAsync(`attrib "${filePath}"`);
+    return attributes.stdout.includes("H");
+  }
+  return false;
+}
+export async function isDirectoryEmpty(directory) {
+  try {
+    const files = await readdir(directory);
+    return files.length === 0;
+  } catch (_error) {
+    return false;
+  }
+}
+export async function rmEnsureDir(dir) {
+  try {
+    if (await pathExists(dir)) {
+      await remove(dir);
+    }
+    await ensuredir(dir);
+  } catch (error) {
+    console.error(`Error while removing/ensuring directory ${dir}: ${error}`);
+    throw error;
+  }
+}

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

@@ -0,0 +1,20 @@
+export declare function readText(filePath: string, options?: BufferEncoding | {
+    encoding?: BufferEncoding | null;
+    flag?: string;
+}): Promise<string | Buffer<ArrayBufferLike>>;
+export declare function readTextSync(filePath: string, options?: BufferEncoding | {
+    encoding?: BufferEncoding | null;
+    flag?: string;
+}): string | Buffer<ArrayBufferLike>;
+export declare function readLines(filePath: string, options?: BufferEncoding | {
+    encoding?: BufferEncoding | null;
+    flag?: string;
+}): Promise<string[]>;
+export declare function readLinesSync(filePath: string, options?: BufferEncoding | {
+    encoding?: BufferEncoding | null;
+    flag?: string;
+}): string[];
+export declare function isDirectory(filePath: string): Promise<boolean>;
+export declare function isDirectorySync(filePath: string): boolean;
+export declare function isSymlink(filePath: string): Promise<boolean>;
+export declare function isSymlinkSync(filePath: string): boolean;

package/bin/impl/file-utils.js

@@ -0,0 +1,63 @@
+import { statSync, lstatSync } from "node:fs";
+import { stat, lstat } from "node:fs/promises";
+import { readFile, readFileSync } from "./read-file.js";
+export async function readText(filePath, options = "utf8") {
+  return readFile(filePath, options);
+}
+export function readTextSync(filePath, options = "utf8") {
+  return readFileSync(filePath, options);
+}
+export async function readLines(filePath, options = { encoding: "utf8" }) {
+  const effectiveOptions = typeof options === "string" ? { encoding: options } : options;
+  const contentBuffer = await readFile(filePath, { ...effectiveOptions, encoding: null });
+  return contentBuffer.toString().split(/\r?\n/);
+}
+export function readLinesSync(filePath, options = { encoding: "utf8" }) {
+  const effectiveOptions = typeof options === "string" ? { encoding: options } : options;
+  const contentBuffer = readFileSync(filePath, { ...effectiveOptions, encoding: null });
+  return contentBuffer.toString().split(/\r?\n/);
+}
+export async function isDirectory(filePath) {
+  try {
+    const stats = await stat(filePath);
+    return stats.isDirectory();
+  } catch (error) {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+      return false;
+    }
+    throw error;
+  }
+}
+export function isDirectorySync(filePath) {
+  try {
+    const stats = statSync(filePath);
+    return stats.isDirectory();
+  } catch (error) {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+      return false;
+    }
+    throw error;
+  }
+}
+export async function isSymlink(filePath) {
+  try {
+    const stats = await lstat(filePath);
+    return stats.isSymbolicLink();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+export function isSymlinkSync(filePath) {
+  try {
+    const stats = lstatSync(filePath);
+    return stats.isSymbolicLink();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}

package/bin/impl/logger.d.ts

@@ -0,0 +1 @@
+export declare const logInternal: (msg: string | (() => string)) => void;

package/bin/impl/logger.js

@@ -0,0 +1,7 @@
+const DEBUG_MODE = true;
+export const logInternal = (msg) => {
+  if (DEBUG_MODE) {
+    const message = typeof msg === "function" ? msg() : msg;
+    console.log(`\x1B[36;2m${message}\x1B[0m`);
+  }
+};

package/bin/impl/mkdirs.js

@@ -1,10 +1,17 @@
 import { mkdirSync, existsSync } from "node:fs";
 import { mkdir, stat } from "node:fs/promises";
 export function mkdirsSync(dir, options) {
-  if (existsSync(dir)) {
-    return;
+  try {
+    if (existsSync(dir)) {
+      return;
+    }
+    return mkdirSync(dir, { recursive: true, mode: options?.mode });
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      return;
+    }
+    throw error;
   }
-  return mkdirSync(dir, { recursive: true, mode: options?.mode });
 }
 export async function mkdirs(dir, options) {
   try {

package/bin/impl/move.d.ts

@@ -2,6 +2,16 @@ export interface MoveOptions {
     overwrite?: boolean;
     /** @deprecated Use `overwrite`. */
     clobber?: boolean;
+    /** Maximum number of retries for EBUSY errors (default: 3) */
+    maxRetries?: number;
+    /** Delay between retries in milliseconds (default: 100) */
+    retryDelay?: number;
+    /** Whether to ensure source exists before moving (default: true) */
+    ensureSource?: boolean;
+    /** Whether to ensure destination directory exists (default: true) */
+    ensureDest?: boolean;
+    /** Whether to verify operation success (default: true) */
+    verify?: boolean;
 }
 /**
  * Moves a file or directory. If the destination is a directory, the source is moved into it.

package/bin/impl/move.js

@@ -3,20 +3,22 @@ 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";
+import { pathExists, pathExistsSync } from "./path-exists.js";
 export function moveSync(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 moveSync is deprecated and will be removed in a future version. Please use 'overwrite' instead."
-    );
-    overwrite = options.clobber;
-  } else {
-    overwrite = false;
+  const {
+    overwrite = options.clobber ?? false,
+    maxRetries = 3,
+    retryDelay = 100,
+    ensureSource = true,
+    ensureDest = true,
+    verify = true
+  } = options;
+  if (ensureSource && !pathExistsSync(src)) {
+    throw new Error(`Source ${src} does not exist.`);
   }
-  const srcStat = statSync(src, { throwIfNoEntry: true });
+  const srcStat = statSync(src, { throwIfNoEntry: false });
   if (!srcStat) {
+    throw new Error(`Source ${src} does not exist.`);
   }
   let destFinal = dest;
   const destStat = statSync(dest, { throwIfNoEntry: false });
@@ -26,39 +28,63 @@ export function moveSync(src, dest, options = {}) {
   if (statSync(destFinal, { throwIfNoEntry: false }) && !overwrite) {
     throw new Error(`Destination ${destFinal} already exists and overwrite is false.`);
   }
-  const destDir = dirname(destFinal);
-  mkdirsSync(destDir);
-  try {
-    renameSync(src, destFinal);
-  } catch (err) {
-    if (err.code === "EXDEV") {
-      copyFileSync(src, destFinal);
-      unlinkSync(src);
-    } else if (err.code === "EISDIR" || err.code === "EPERM") {
-      copyFileSync(src, destFinal);
-      unlinkSync(src);
-    } else {
+  if (ensureDest) {
+    const destDir = dirname(destFinal);
+    mkdirsSync(destDir);
+  }
+  let lastError = null;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      renameSync(src, destFinal);
+      if (verify && !pathExistsSync(destFinal)) {
+        throw new Error(`Move operation failed: destination ${destFinal} does not exist after move`);
+      }
+      return;
+    } catch (err) {
+      lastError = err;
+      if (err.code === "EXDEV") {
+        copyFileSync(src, destFinal);
+        unlinkSync(src);
+        if (verify && !pathExistsSync(destFinal)) {
+          throw new Error(`Copy and unlink operation failed: destination ${destFinal} does not exist after operation`);
+        }
+        return;
+      } else if (err.code === "EISDIR" || err.code === "EPERM") {
+        copyFileSync(src, destFinal);
+        unlinkSync(src);
+        if (verify && !pathExistsSync(destFinal)) {
+          throw new Error(`Copy and unlink operation failed: destination ${destFinal} does not exist after operation`);
+        }
+        return;
+      } else if (err.code === "EBUSY" && attempt < maxRetries - 1) {
+        const start = Date.now();
+        while (Date.now() - start < retryDelay) {
+        }
+        continue;
+      }
       throw err;
     }
   }
+  throw lastError;
 }
 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 {
+    overwrite = options.clobber ?? false,
+    maxRetries = 3,
+    retryDelay = 100,
+    ensureSource = true,
+    ensureDest = true,
+    verify = true
+  } = options;
+  if (ensureSource && !await pathExists(src)) {
+    throw new Error(`Source ${src} does not exist.`);
   }
   const srcStat = await stat(src).catch((e) => {
     if (e.code === "ENOENT") return null;
     throw e;
   });
   if (!srcStat) {
+    throw new Error(`Source ${src} does not exist.`);
   }
   let destFinal = dest;
   const destStat = await stat(dest).catch((e) => {
@@ -75,19 +101,40 @@ export async function move(src, dest, options = {}) {
   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 {
+  if (ensureDest) {
+    const destDir = dirname(destFinal);
+    await mkdirs(destDir);
+  }
+  let lastError = null;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      await rename(src, destFinal);
+      if (verify && !await pathExists(destFinal)) {
+        throw new Error(`Move operation failed: destination ${destFinal} does not exist after move`);
+      }
+      return;
+    } catch (err) {
+      lastError = err;
+      if (err.code === "EXDEV") {
+        await copyFile(src, destFinal);
+        await unlink(src);
+        if (verify && !await pathExists(destFinal)) {
+          throw new Error(`Copy and unlink operation failed: destination ${destFinal} does not exist after operation`);
+        }
+        return;
+      } else if (err.code === "EISDIR" || err.code === "EPERM") {
+        await copyFile(src, destFinal);
+        await unlink(src);
+        if (verify && !await pathExists(destFinal)) {
+          throw new Error(`Copy and unlink operation failed: destination ${destFinal} does not exist after operation`);
+        }
+        return;
+      } else if (err.code === "EBUSY" && attempt < maxRetries - 1) {
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        continue;
+      }
       throw err;
     }
   }
+  throw lastError;
 }

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

@@ -3,28 +3,18 @@ export interface ReadFileOptions {
     flag?: string;
 }
 /**
- * Reads the entire contents of a file.
+ * Synchronously 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 The file content as a string or Buffer.
+ * @returns The contents of the file.
  */
-export declare function readFileSync(path: string, options: BufferEncoding | (ReadFileOptions & {
-    encoding: BufferEncoding;
-})): string;
-export declare function readFileSync(path: string, options?: (ReadFileOptions & {
-    encoding?: null;
-}) | null): Buffer;
+export declare function readFileSync(path: string, options?: BufferEncoding | ReadFileOptions): string | 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.
+ * @returns A promise that resolves with the contents of the file.
  */
-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>;
+export declare function readFile(path: string, options?: BufferEncoding | ReadFileOptions): Promise<string | Buffer>;

package/bin/impl/read-file.js

@@ -1,5 +1,7 @@
 import { readFileSync as nodeReadFileSync } from "node:fs";
 import { readFile as nodeReadFileAsync } from "node:fs/promises";
+import { isBun, getFileBun } from "./bun.js";
+import { logInternal } from "./logger.js";
 export function readFileSync(path, options) {
   let encoding;
   let flag;
@@ -9,6 +11,40 @@ export function readFileSync(path, options) {
     encoding = options.encoding;
     flag = options.flag;
   }
+  if (isBun) {
+    try {
+      const file = getFileBun(path);
+      if (encoding) {
+        try {
+          const text = file.text();
+          if (text instanceof Promise) {
+            throw new Error("Bun's text() returned a Promise in sync context");
+          }
+          return text;
+        } catch (_error) {
+          const buffer = file.arrayBuffer();
+          if (buffer instanceof Promise) {
+            throw new Error("Bun's arrayBuffer() returned a Promise in sync context");
+          }
+          return Buffer.from(buffer).toString(encoding);
+        }
+      }
+      try {
+        const buffer = file.arrayBuffer();
+        if (buffer instanceof Promise) {
+          throw new Error("Bun's arrayBuffer() returned a Promise in sync context");
+        }
+        return Buffer.from(buffer);
+      } catch (_error) {
+        const text = file.text();
+        if (text instanceof Promise) {
+          throw new Error("Bun's text() returned a Promise in sync context");
+        }
+        return Buffer.from(text);
+      }
+    } catch (error) {
+    }
+  }
   if (encoding) {
     return nodeReadFileSync(path, { encoding, flag });
   }
@@ -23,6 +59,27 @@ export async function readFile(path, options) {
     encoding = options.encoding;
     flag = options.flag;
   }
+  if (isBun) {
+    try {
+      const file = getFileBun(path);
+      if (encoding) {
+        try {
+          return await file.text();
+        } catch (_error) {
+          const buffer = await file.arrayBuffer();
+          return Buffer.from(buffer).toString(encoding);
+        }
+      }
+      try {
+        const buffer = await file.arrayBuffer();
+        return Buffer.from(buffer);
+      } catch (_error) {
+        const text = await file.text();
+        return Buffer.from(text);
+      }
+    } catch (error) {
+    }
+  }
   if (encoding) {
     return nodeReadFileAsync(path, { encoding, flag });
   }

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

@@ -3,9 +3,12 @@ export interface ReadJsonOptions {
     flag?: string;
     reviver?: (key: string, value: unknown) => unknown;
     throws?: boolean;
+    defaultValue?: unknown;
+    ensure?: boolean;
 }
 /**
  * Reads a JSON file and then parses it into an object.
+ * If the file doesn't exist and ensure is true, creates the file with defaultValue.
  *
  * @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.