@reliverse/relifso 1.3.1 → 1.4.0

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/{node/mkdirs.js → 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/{node/move.d.ts → 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

@@ -0,0 +1,140 @@
+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";
+import { pathExists, pathExistsSync } from "./path-exists.js";
+export function moveSync(src, dest, options = {}) {
+  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: false });
+  if (!srcStat) {
+    throw new Error(`Source ${src} does not exist.`);
+  }
+  let destFinal = dest;
+  const destStat = statSync(dest, { throwIfNoEntry: false });
+  if (destStat?.isDirectory()) {
+    destFinal = joinPath(dest, basename(src));
+  }
+  if (statSync(destFinal, { throwIfNoEntry: false }) && !overwrite) {
+    throw new Error(`Destination ${destFinal} already exists and overwrite is false.`);
+  }
+  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 = {}) {
+  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) => {
+    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.`);
+  }
+  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

@@ -0,0 +1,20 @@
+export interface ReadFileOptions {
+    encoding?: BufferEncoding | null;
+    flag?: string;
+}
+/**
+ * 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 contents of the file.
+ */
+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 contents of the file.
+ */
+export declare function readFile(path: string, options?: BufferEncoding | ReadFileOptions): Promise<string | Buffer>;

package/bin/impl/read-file.js

@@ -0,0 +1,87 @@
+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;
+  if (typeof options === "string") {
+    encoding = options;
+  } else if (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 });
+  }
+  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 (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 });
+  }
+  return nodeReadFileAsync(path, { encoding: null, flag });
+}

package/bin/impl/{node/read-json.d.ts → 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.

package/bin/impl/read-json.js

@@ -0,0 +1,129 @@
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { isBun, getFileBun } from "./bun.js";
+import { logInternal } from "./logger.js";
+import { outputJsonSync } from "./output-json.js";
+import { pathExistsSync } from "./path-exists.js";
+export function readJsonSync(file, options) {
+  let encoding = "utf8";
+  let reviver;
+  let throws = true;
+  let defaultValue = { sync: true };
+  let ensure = true;
+  if (typeof options === "string") {
+    encoding = options;
+  } else if (options) {
+    encoding = options.encoding ?? encoding;
+    reviver = options.reviver;
+    if (options.throws !== void 0) {
+      throws = options.throws;
+    }
+    if (options.defaultValue !== void 0) {
+      defaultValue = options.defaultValue;
+    }
+    if (options.ensure !== void 0) {
+      ensure = options.ensure;
+    }
+  }
+  try {
+    if (!pathExistsSync(file) && ensure) {
+      outputJsonSync(file, defaultValue);
+      return defaultValue;
+    }
+    const data = readFileSync(file, { encoding });
+    if (!data || !data.trim()) {
+      return defaultValue;
+    }
+    try {
+      const parsed = JSON.parse(data, reviver);
+      if (parsed === null || typeof parsed !== "object") {
+        if (throws) {
+          throw new Error("Invalid JSON data: expected an object");
+        }
+        return defaultValue;
+      }
+      return parsed;
+    } catch (parseError) {
+      if (throws) {
+        throw parseError;
+      }
+      return defaultValue;
+    }
+  } catch (err) {
+    if (throws) {
+      throw err;
+    }
+    return defaultValue;
+  }
+}
+export async function readJson(file, options) {
+  let encoding = "utf8";
+  let reviver;
+  let throws = true;
+  let flag;
+  let defaultValue = {};
+  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;
+    }
+    if (options.defaultValue !== void 0) {
+      defaultValue = options.defaultValue;
+    }
+  }
+  try {
+    if (isBun) {
+      try {
+        const fileRef = getFileBun(file);
+        try {
+          const content = await fileRef.text();
+          if (!content || !content.trim()) {
+            return defaultValue;
+          }
+          const parsed = JSON.parse(content, reviver);
+          if (parsed === null || typeof parsed !== "object") {
+            if (throws) {
+              throw new Error("Invalid JSON data: expected an object");
+            }
+            return defaultValue;
+          }
+          return parsed;
+        } catch (parseError) {
+          if (throws) {
+            throw parseError;
+          }
+          return defaultValue;
+        }
+      } catch (error) {
+      }
+    }
+    const data = await readFile(file, { encoding, flag });
+    if (!data || !data.trim()) {
+      return defaultValue;
+    }
+    try {
+      const parsed = JSON.parse(data, reviver);
+      if (parsed === null || typeof parsed !== "object") {
+        if (throws) {
+          throw new Error("Invalid JSON data: expected an object");
+        }
+        return defaultValue;
+      }
+      return parsed;
+    } catch (parseError) {
+      if (throws) {
+        throw parseError;
+      }
+      return defaultValue;
+    }
+  } catch (err) {
+    if (throws) {
+      throw err;
+    }
+    return defaultValue;
+  }
+}

package/bin/impl/write-file.js

@@ -0,0 +1,48 @@
+import { writeFileSync as nodeWriteFileSync } from "node:fs";
+import { mkdir, writeFile as nodeWriteFileAsync, stat } from "node:fs/promises";
+import path from "node:path";
+import { isBun, getFileBun } from "./bun.js";
+import { logInternal } from "./logger.js";
+import { mkdirsSync } from "./mkdirs.js";
+export function writeFileSync(file, data, options) {
+  const dir = path.dirname(file.toString());
+  mkdirsSync(dir);
+  if (isBun) {
+    try {
+      nodeWriteFileSync(file, data, options);
+      return;
+    } catch (_error) {
+    }
+  }
+  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;
+    }
+  }
+  if (isBun) {
+    try {
+      const filePath = file.toString();
+      const bunFile = getFileBun(filePath);
+      let writeData;
+      if (typeof data === "string") {
+        writeData = data;
+      } else if (data instanceof Uint8Array) {
+        writeData = data;
+      } else {
+        writeData = new Uint8Array(data.buffer);
+      }
+      await Bun.write(bunFile, writeData);
+      return;
+    } catch (_error) {
+    }
+  }
+  return nodeWriteFileAsync(file, data, options);
+}

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

@@ -0,0 +1,30 @@
+import type { Mode } from "node:fs";
+export interface JsonStringifyOptions {
+    replacer?: (key: string, value: unknown) => unknown | (number | string)[] | null;
+    spaces?: string | number;
+}
+export interface WriteJsonOptions {
+    encoding?: BufferEncoding | null;
+    mode?: Mode;
+    flag?: string;
+    replacer?: (key: string, value: unknown) => unknown | (number | string)[] | null;
+    spaces?: string | number;
+    throws?: boolean;
+}
+/**
+ * Synchronously writes a JSON file.
+ *
+ * @param file - The path to the file.
+ * @param object - The object to write.
+ * @param options - Options for writing the file or stringifying JSON. Can be an encoding string or an object.
+ */
+export declare function writeJsonSync(file: string, object: unknown, options?: BufferEncoding | WriteJsonOptions): void;
+/**
+ * Asynchronously writes a JSON file.
+ *
+ * @param file - The path to the file.
+ * @param object - The object to write.
+ * @param options - Options for writing the file or stringifying JSON. Can be an encoding string or an object.
+ * @returns A promise that resolves when the file has been written.
+ */
+export declare function writeJson(file: string, object: unknown, options?: BufferEncoding | WriteJsonOptions): Promise<void>;