@reliverse/relifso 1.4.5 → 2.2.8

package/bin/impl/dive.js

@@ -1,145 +0,0 @@
-import { readdirSync, statSync } from "node:fs";
-import { readdir as nodeReaddirInternal, stat as nodeStatInternal } from "node:fs/promises";
-import { join } from "node:path";
-import { join as pathJoin } from "node:path";
-import { isBun } from "./bun.js";
-import { getStats } from "./stats.js";
-export function* diveSync(dir, callbackOrOptions, options) {
-  const currentDepth = 0;
-  let actualOptions = {
-    recursive: true,
-    files: true,
-    directories: false
-    // fs-extra's dive by default only yields files
-  };
-  let callback;
-  if (typeof callbackOrOptions === "function") {
-    callback = callbackOrOptions;
-    if (options) {
-      actualOptions = { ...actualOptions, ...options };
-    }
-  } else if (typeof callbackOrOptions === "object") {
-    actualOptions = { ...actualOptions, ...callbackOrOptions };
-  }
-  function* walk(currentPath, depth) {
-    if (actualOptions.depth !== void 0 && depth > actualOptions.depth) {
-      return;
-    }
-    const entries = readdirSync(currentPath, { withFileTypes: true });
-    for (const entry of entries) {
-      const entryPath = join(currentPath, entry.name);
-      if (!actualOptions.all && entry.name.startsWith(".")) {
-        continue;
-      }
-      if (actualOptions.ignore) {
-        if (Array.isArray(actualOptions.ignore) && actualOptions.ignore.includes(entry.name)) {
-          continue;
-        }
-        if (actualOptions.ignore instanceof RegExp && actualOptions.ignore.test(entryPath)) {
-          continue;
-        }
-      }
-      const stat = statSync(entryPath);
-      if (entry.isFile()) {
-        if (actualOptions.files) {
-          if (callback) callback(entryPath, stat);
-          yield entryPath;
-        }
-      } else if (entry.isDirectory()) {
-        if (actualOptions.directories) {
-          if (callback) callback(entryPath, stat);
-          yield entryPath;
-        }
-        if (actualOptions.recursive) {
-          yield* walk(entryPath, depth + 1);
-        }
-      }
-    }
-  }
-  yield* walk(dir, currentDepth);
-}
-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 getStats(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/empty.d.ts

@@ -1,28 +0,0 @@
-interface EmptyFileOptions {
-    /**
-     * If true, will replace all object literals with empty objects {}
-     * Only works with JSON files
-     */
-    emptyObjects?: boolean;
-}
-export declare function emptyDirSync(dir: string): void;
-export declare function emptyDir(dir: string): Promise<void>;
-/**
- * Empties an object by removing all its properties
- * @param obj The object to empty
- * @returns The empty object
- */
-export declare function emptyObject<T extends object>(obj: T): T;
-/**
- * Empties a file by removing all its contents
- * @param filePath Path to the file
- * @param options Options for emptying the file
- */
-export declare function emptyFile(filePath: string, options?: EmptyFileOptions): Promise<void>;
-/**
- * Synchronous version of emptyFile
- * @param filePath Path to the file
- * @param options Options for emptying the file
- */
-export declare function emptyFileSync(filePath: string, options?: EmptyFileOptions): void;
-export {};

package/bin/impl/empty.js

@@ -1,75 +0,0 @@
-import { existsSync, readdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
-import { readdir, rm, stat, writeFile, readFile } from "node:fs/promises";
-import path from "node:path";
-export function emptyDirSync(dir) {
-  if (!existsSync(dir)) {
-    return;
-  }
-  for (const file of readdirSync(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 });
-  }
-}
-export function emptyObject(obj) {
-  for (const key in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, key)) {
-      delete obj[key];
-    }
-  }
-  return obj;
-}
-export async function emptyFile(filePath, options = {}) {
-  try {
-    await stat(filePath);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return;
-    }
-    throw error;
-  }
-  if (options.emptyObjects && filePath.toLowerCase().endsWith(".json")) {
-    try {
-      const content = await readFile(filePath, "utf-8");
-      const data = JSON.parse(content);
-      if (typeof data === "object" && data !== null) {
-        const emptyData = emptyObject(data);
-        await writeFile(filePath, JSON.stringify(emptyData, null, 2));
-        return;
-      }
-    } catch (error) {
-      console.warn(`Failed to parse JSON file ${filePath}, falling back to regular file emptying:`, error);
-    }
-  }
-  await writeFile(filePath, "");
-}
-export function emptyFileSync(filePath, options = {}) {
-  if (!existsSync(filePath)) {
-    return;
-  }
-  if (options.emptyObjects && filePath.toLowerCase().endsWith(".json")) {
-    try {
-      const content = readFileSync(filePath, "utf-8");
-      const data = JSON.parse(content);
-      if (typeof data === "object" && data !== null) {
-        const emptyData = emptyObject(data);
-        writeFileSync(filePath, JSON.stringify(emptyData, null, 2));
-        return;
-      }
-    } catch (error) {
-      console.warn(`Failed to parse JSON file ${filePath}, falling back to regular file emptying:`, error);
-    }
-  }
-  writeFileSync(filePath, "");
-}

package/bin/impl/extras.d.ts

@@ -1,35 +0,0 @@
-import { exec } from "node:child_process";
-export declare function readText(filePath: string, options?: BufferEncoding | {
-    encoding?: BufferEncoding | null;
-    flag?: string;
-}): Promise<string>;
-export declare function readTextSync(filePath: string, options?: BufferEncoding | {
-    encoding?: BufferEncoding | null;
-    flag?: string;
-}): string;
-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;
-export declare const execAsync: typeof exec.__promisify__;
-export declare function setHiddenAttribute(folderPath: string): Promise<void>;
-export declare function isHiddenAttribute(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

@@ -1,112 +0,0 @@
-import { ensuredir } from "@reliverse/relifso";
-import { exec } from "node:child_process";
-import { statSync, lstatSync } from "node:fs";
-import { readdir } from "node:fs/promises";
-import { stat, lstat } from "node:fs/promises";
-import { promisify } from "node:util";
-import { pathExists } from "./path-exists.js";
-import { remove } from "./remove.js";
-import { readFile, readFileSync } from "./read-file.js";
-export async function readText(filePath, options = "utf8") {
-  const effectiveOptions = typeof options === "string" ? { encoding: options } : { ...options, encoding: options.encoding || "utf8" };
-  return readFile(filePath, effectiveOptions);
-}
-export function readTextSync(filePath, options = "utf8") {
-  const effectiveOptions = typeof options === "string" ? { encoding: options } : { ...options, encoding: options.encoding || "utf8" };
-  return readFileSync(filePath, effectiveOptions);
-}
-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;
-  }
-}
-export const execAsync = promisify(exec);
-export async function setHiddenAttribute(folderPath) {
-  if (process.platform === "win32") {
-    try {
-      if (await pathExists(folderPath)) {
-        const isAlreadyHidden = await isHiddenAttribute(folderPath);
-        if (!isAlreadyHidden) {
-          await execAsync(`attrib +h "${folderPath}"`);
-        }
-      }
-    } catch (error) {
-      console.warn("Failed to set hidden attribute:", String(error));
-    }
-  }
-}
-export async function isHiddenAttribute(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/json-utils.d.ts

@@ -1,30 +0,0 @@
-import type { WriteJsonOptions } from "./write-json.js";
-export interface JsonUtilsOptions extends WriteJsonOptions {
-    /**
-     * Whether to preserve comments when reading JSONC files
-     * @default false
-     */
-    preserveComments?: boolean;
-    /**
-     * Whether to include comments when writing JSONC files
-     * @default false
-     */
-    includeComments?: boolean;
-}
-/**
- * Validates and repairs JSON/JSONC data if necessary.
- * @param data - The JSON/JSONC data to validate and repair
- * @param options - Options for validation and repair
- * @returns The repaired JSON/JSONC data if needed, or the original data if valid
- */
-export declare function validateAndRepairJson(data: unknown, options?: JsonUtilsOptions): unknown;
-/**
- * Ensures that the directory for the JSON/JSONC file exists and then writes the data to the file.
- * This is a utility function to avoid circular dependencies.
- */
-export declare function ensureJsonFileSync(file: string, data: unknown, options?: JsonUtilsOptions): void;
-/**
- * Ensures that the directory for the JSON/JSONC file exists and then asynchronously writes the data to the file.
- * This is a utility function to avoid circular dependencies.
- */
-export declare function ensureJsonFile(file: string, data: unknown, options?: JsonUtilsOptions): Promise<void>;

package/bin/impl/json-utils.js

@@ -1,46 +0,0 @@
-import { dirname } from "node:path";
-import { extname } from "node:path";
-import { parseJsonc, isValidJsonc } from "../utils/json/regular/jsonc.js";
-import { jsonrepair } from "../utils/json/regular/jsonrepair.js";
-import { mkdirsSync } from "./mkdirs.js";
-import { mkdirs } from "./mkdirs.js";
-import { writeJsonSync } from "./write-json.js";
-import { writeJson } from "./write-json.js";
-export function validateAndRepairJson(data, options = {}) {
-  if (typeof data === "string") {
-    try {
-      JSON.parse(data);
-      return data;
-    } catch {
-      const isJsonc = extname(data).toLowerCase() === ".jsonc" || isValidJsonc(data);
-      if (isJsonc) {
-        try {
-          return parseJsonc(data, { preserveComments: options.preserveComments });
-        } catch {
-          return jsonrepair(data);
-        }
-      } else {
-        return jsonrepair(data);
-      }
-    }
-  }
-  return data;
-}
-export function ensureJsonFileSync(file, data, options) {
-  const dir = dirname(file);
-  mkdirsSync(dir);
-  const repairedData = validateAndRepairJson(data, options);
-  writeJsonSync(file, repairedData, {
-    ...options,
-    spaces: 2
-  });
-}
-export async function ensureJsonFile(file, data, options) {
-  const dir = dirname(file);
-  await mkdirs(dir);
-  const repairedData = validateAndRepairJson(data, options);
-  await writeJson(file, repairedData, {
-    ...options,
-    spaces: 2
-  });
-}

package/bin/impl/mkdirs.d.ts

@@ -1,7 +0,0 @@
-interface MakeDirectoryOptions {
-    recursive?: boolean;
-    mode?: number | string;
-}
-export declare function mkdirsSync(dir: string, options?: MakeDirectoryOptions): string | undefined;
-export declare function mkdirs(dir: string, options?: MakeDirectoryOptions): Promise<string | undefined>;
-export {};

package/bin/impl/mkdirs.js

@@ -1,28 +0,0 @@
-import { mkdirSync, existsSync } from "node:fs";
-import { mkdir, stat } from "node:fs/promises";
-export function mkdirsSync(dir, options) {
-  try {
-    if (existsSync(dir)) {
-      return;
-    }
-    return mkdirSync(dir, { recursive: true, mode: options?.mode });
-  } catch (error) {
-    if (error.code === "EEXIST") {
-      return;
-    }
-    throw error;
-  }
-}
-export async function mkdirs(dir, options) {
-  try {
-    const dirStat = await stat(dir);
-    if (dirStat.isDirectory()) {
-      return void 0;
-    }
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      throw error;
-    }
-  }
-  return mkdir(dir, { recursive: true, mode: options?.mode });
-}

package/bin/impl/move.d.ts

@@ -1,28 +0,0 @@
-export interface MoveOptions {
-    /** @deprecated Use `overwrite` instead. This option will be removed in a future. */
-    force?: boolean;
-    /** Whether to overwrite existing files. Default: false */
-    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.
- * If the destination exists and is a file, it will be overwritten if `overwrite` is true.
- *
- * @param src - The source path.
- * @param dest - The destination path.
- * @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,140 +0,0 @@
-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;
-}