@reliverse/relifso 1.4.5 → 2.2.8

package/dist/mod.js

@@ -0,0 +1,77 @@
+import { copy, move } from "./copy.js";
+import {
+  emptyDir,
+  ensureDir,
+  ensureFile,
+  listFiles,
+  mkdirp,
+  pathExists,
+  readdir,
+  readdirRecursive,
+  remove,
+  sizeOf
+} from "./dir.js";
+import {
+  appendFile,
+  outputFile,
+  outputJson,
+  readFile,
+  readJSONSync,
+  readJson,
+  writeFile,
+  writeJson
+} from "./file.js";
+import { readLines, touch } from "./helpers.js";
+import { ensureLink, ensureSymlink } from "./links.js";
+export { copy, move };
+export {
+  emptyDir,
+  ensureDir,
+  ensureFile,
+  listFiles,
+  mkdirp,
+  pathExists,
+  readdir,
+  readdirRecursive,
+  remove,
+  sizeOf
+};
+export {
+  appendFile,
+  outputFile,
+  outputJson,
+  readFile,
+  readJson,
+  readJSONSync,
+  writeFile,
+  writeJson
+};
+export { readLines, touch };
+export { ensureLink, ensureSymlink };
+const fs = {
+  appendFile,
+  copy,
+  move,
+  emptyDir,
+  ensureDir,
+  ensureFile,
+  listFiles,
+  mkdirp,
+  pathExists,
+  readdir,
+  readdirRecursive,
+  remove,
+  sizeOf,
+  outputFile,
+  outputJson,
+  readFile,
+  readJson,
+  readJSONSync,
+  writeFile,
+  writeJson,
+  readLines,
+  touch,
+  ensureLink,
+  ensureSymlink
+};
+export default fs;

package/dist/types.d.ts

@@ -0,0 +1,50 @@
+export type PathLike = string | URL;
+export type FileInput = string | ArrayBuffer | SharedArrayBuffer | NodeJS.ArrayBufferView | Blob;
+export type FileEncoding = "utf8" | "utf-8" | "ascii" | "base64" | "hex" | "latin1" | "ucs-2" | "ucs2" | "utf16le" | "binary";
+export interface ReadFileOptions {
+    readonly encoding?: FileEncoding;
+}
+export interface WriteFileOptions {
+    readonly encoding?: FileEncoding;
+    readonly mode?: number;
+    readonly signal?: AbortSignal;
+}
+export interface JsonWriteOptions extends WriteFileOptions {
+    readonly spaces?: number;
+}
+export interface CopyOptions {
+    readonly overwrite?: boolean;
+    readonly dereference?: boolean;
+    readonly filter?: (path: string) => boolean | Promise<boolean>;
+}
+export interface RemoveOptions {
+    readonly force?: boolean;
+}
+export interface ListFilesOptions {
+    readonly extensions?: readonly string[];
+    readonly followSymlinks?: boolean;
+}
+export interface EnsureSymlinkOptions {
+    readonly type?: "file" | "dir" | "junction";
+}
+export interface ReaddirOptions {
+    readonly withFileTypes?: boolean;
+}
+export interface EmptyDirOptions {
+    readonly filter?: (path: string) => boolean | Promise<boolean>;
+}
+export interface SizeOfOptions {
+    readonly followSymlinks?: boolean;
+}
+export interface TouchOptions {
+    readonly mtime?: Date;
+    readonly atime?: Date;
+}
+export interface ReadLinesOptions {
+    readonly trim?: boolean;
+    readonly skipEmpty?: boolean;
+    readonly maxLines?: number;
+}
+export interface MoveOptions {
+    readonly overwrite?: boolean;
+}

package/package.json

@@ -1,49 +1,22 @@
 {
-  "dependencies": {},
-  "description": "@reliverse/relifso is a modern node and bun filesystem toolkit. drop-in replacement for `node:fs` and `fs-extra` — powered by native promises, built with es modules, and packed with dx-focused and bun-aware utilities.",
-  "homepage": "https://docs.reliverse.org",
-  "license": "MIT",
   "name": "@reliverse/relifso",
+  "description": "Bun-first fs-extra style helpers (copy, ensure*, output*) for Reliverse ecosystem",
+  "author": "reliverse",
+  "version": "2.2.8",
+  "private": false,
   "type": "module",
-  "version": "1.4.5",
-  "keywords": [
-    "fs",
-    "file",
-    "file system",
-    "copy",
-    "directory",
-    "lite",
-    "mkdirp",
-    "mkdir",
-    "mkdirs",
-    "recursive",
-    "json",
-    "read",
-    "write",
-    "extra",
-    "delete",
-    "remove",
-    "touch",
-    "create",
-    "text",
-    "output",
-    "move",
-    "promise"
-  ],
-  "devDependencies": {},
   "exports": {
-    ".": "./bin/mod.js"
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "default": "./dist/mod.js"
+    }
   },
-  "files": [
-    "bin",
-    "package.json",
-    "README.md",
-    "LICENSE",
-    "LICENSES"
-  ],
-  "main": "./bin/mod.js",
-  "module": "./bin/mod.js",
   "publishConfig": {
     "access": "public"
-  }
-}
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "license": "MIT"
+}

package/LICENSE

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) Nazar Kornienko (blefnk), Reliverse
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/LICENSES

@@ -1,16 +0,0 @@
-LICENSES
-
----
-
-MIT License
-
-Copyright (c) Nazar Kornienko (blefnk), Reliverse
-
-See LICENSE file for full license text.
-
----
-
-NOTICES
-
-Some parts of this project are based on and significantly adapt:
-- https://github.com/josdejong/jsonrepair/tree/acab2a4 – ISC © Jos de Jong (josdejong)

package/bin/impl/bun.d.ts

@@ -1,11 +0,0 @@
-export declare const isBun: string | false;
-/**
- * Get a file reference with validation and error handling
- * Uses Bun's optimized API when available, throws error otherwise
- */
-export declare function getFileBun(path: string): Bun.BunFile;
-/**
- * Get file type
- * Uses Bun's optimized API when available, throws error otherwise
- */
-export declare function getFileTypeBun(path: string): Promise<string>;

package/bin/impl/bun.js

@@ -1,23 +0,0 @@
-import { logInternal } from "../utils/log.js";
-export const isBun = typeof process !== "undefined" && process.versions.bun;
-export function getFileBun(path) {
-  if (!isBun) {
-    throw new Error("Bun runtime not detected");
-  }
-  try {
-    return Bun.file(path);
-  } catch (error) {
-    throw error;
-  }
-}
-export async function getFileTypeBun(path) {
-  if (!isBun) {
-    throw new Error("Bun runtime not detected");
-  }
-  try {
-    const file = Bun.file(path);
-    return file.type;
-  } catch (error) {
-    throw error;
-  }
-}

package/bin/impl/copy.d.ts

@@ -1,40 +0,0 @@
-export interface CopyOptions {
-    /** @deprecated Use `overwrite` instead. This option will be removed in a future. */
-    force?: boolean;
-    /** Whether to overwrite existing files. Default: true */
-    overwrite?: boolean;
-    /** @deprecated Use `overwrite`. */
-    clobber?: boolean;
-    /** Whether to preserve timestamps. Default: false */
-    preserveTimestamps?: boolean;
-    /** Whether to recursively copy directories. Default: false */
-    recursive?: boolean;
-    /** Whether to dereference symlinks. Default: false */
-    dereference?: boolean;
-    /** Whether to throw an error if the destination exists. Default: false */
-    errorOnExist?: boolean;
-    /** Whether to ensure source exists before copying (default: true) */
-    ensureSource?: boolean;
-    /** Whether to ensure destination directory exists (default: true) */
-    ensureDest?: boolean;
-    /** Whether to verify operation success (default: true) */
-    verify?: boolean;
-    /** @deprecated Not used. */
-    filter?: (src: string, dest: string) => boolean;
-}
-/**
- * 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 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,229 +0,0 @@
-import {
-  copyFileSync,
-  statSync,
-  constants as fsConstants,
-  readdirSync,
-  rmSync,
-  lstatSync,
-  readlinkSync,
-  symlinkSync
-} from "node:fs";
-import {
-  stat as statAsync,
-  copyFile as copyFileAsync,
-  constants as fsConstantsAsync,
-  readdir,
-  rm,
-  lstat,
-  readlink,
-  symlink
-} from "node:fs/promises";
-import { dirname, join as joinPath } from "node:path";
-import { mkdirsSync } from "./mkdirs.js";
-import { mkdirs } from "./mkdirs.js";
-import { logInternal } from "../utils/log.js";
-import { isBun, getFileBun } from "./bun.js";
-import { pathExists, pathExistsSync } from "./path-exists.js";
-import { getStats, getStatsSync } from "./stats.js";
-export function copySync(src, dest, options = {}) {
-  const {
-    overwrite = options.clobber ?? true,
-    force = true,
-    recursive = true,
-    dereference = false,
-    errorOnExist = false,
-    ensureSource = true,
-    ensureDest = true,
-    verify = true
-  } = options;
-  if (ensureSource && !pathExistsSync(src)) {
-    throw new Error(`Source ${src} does not exist.`);
-  }
-  if (isBun && !dereference) {
-    try {
-      const srcStat2 = getStatsSync(src);
-      if (!srcStat2.isDirectory()) {
-        try {
-          const destStat = getStatsSync(dest);
-          if (destStat) {
-            if (errorOnExist) {
-              throw new Error(`Destination ${dest} already exists.`);
-            }
-            if (!force && !overwrite) {
-              throw new Error(`Destination ${dest} already exists and overwrite is false.`);
-            }
-            if (force || overwrite) {
-              rmSync(dest, { force: true });
-            }
-          }
-        } catch (_error) {
-        }
-        if (ensureDest) {
-          const destDir = dirname(dest);
-          mkdirsSync(destDir);
-        }
-        try {
-          copyFileSync(src, dest, fsConstants.COPYFILE_FICLONE);
-          if (verify && !pathExistsSync(dest)) {
-            throw new Error(`Copy operation failed: destination ${dest} does not exist after copy`);
-          }
-          return;
-        } catch (error) {
-        }
-      }
-    } catch (error) {
-    }
-  }
-  const srcStat = dereference ? statSync(src, { throwIfNoEntry: true }) : lstatSync(src, { throwIfNoEntry: true });
-  if (srcStat.isDirectory()) {
-    if (!recursive) {
-      throw new Error(`Cannot copy directory ${src} without recursive flag`);
-    }
-    if (ensureDest) {
-      mkdirsSync(dest);
-    }
-    const entries = readdirSync(src, { withFileTypes: true });
-    for (const entry of entries) {
-      const srcPath = joinPath(src, entry.name);
-      const destPath = joinPath(dest, entry.name);
-      if (entry.isDirectory()) {
-        copySync(srcPath, destPath, options);
-      } else if (entry.isFile()) {
-        copyFileSync(srcPath, destPath, fsConstants.COPYFILE_FICLONE);
-      } else if (entry.isSymbolicLink()) {
-        const target = readlinkSync(srcPath);
-        symlinkSync(target, destPath);
-      }
-    }
-    if (verify && !pathExistsSync(dest)) {
-      throw new Error(`Copy operation failed: destination directory ${dest} does not exist after copy`);
-    }
-  } else {
-    if (ensureDest) {
-      mkdirsSync(dirname(dest));
-    }
-    const destExists = statSync(dest, { throwIfNoEntry: false });
-    if (destExists) {
-      if (errorOnExist) {
-        throw new Error(`Destination ${dest} already exists.`);
-      }
-      if (!force && !overwrite) {
-        throw new Error(`Destination ${dest} already exists and overwrite is false.`);
-      }
-      if (force || overwrite) {
-        rmSync(dest, { force: true });
-      }
-    }
-    copyFileSync(src, dest, fsConstants.COPYFILE_FICLONE);
-    if (verify && !pathExistsSync(dest)) {
-      throw new Error(`Copy operation failed: destination file ${dest} does not exist after copy`);
-    }
-  }
-}
-export async function copy(src, dest, options = {}) {
-  const {
-    overwrite = options.clobber ?? true,
-    force = true,
-    recursive = true,
-    dereference = false,
-    errorOnExist = false,
-    ensureSource = true,
-    ensureDest = true,
-    verify = true
-  } = options;
-  if (ensureSource && !await pathExists(src)) {
-    throw new Error(`Source ${src} does not exist.`);
-  }
-  if (isBun && !dereference) {
-    try {
-      const srcStat2 = await getStats(src);
-      if (!srcStat2.isDirectory()) {
-        const srcFile = getFileBun(src);
-        const destFile = getFileBun(dest);
-        try {
-          const destStat = await getStats(dest);
-          if (destStat) {
-            if (errorOnExist) {
-              throw new Error(`Destination ${dest} already exists.`);
-            }
-            if (!force && !overwrite) {
-              throw new Error(`Destination ${dest} already exists and overwrite is false.`);
-            }
-            if (force || overwrite) {
-              await rm(dest, { force: true });
-            }
-          }
-        } catch (_error) {
-        }
-        if (ensureDest) {
-          const destDir = dirname(dest);
-          await mkdirs(destDir);
-        }
-        try {
-          const content = await srcFile?.text();
-          await Bun.write(destFile, content);
-          if (verify && !await pathExists(dest)) {
-            throw new Error(`Bun write failed: destination ${dest} does not exist after write`);
-          }
-          return;
-        } catch (error) {
-        }
-      }
-    } catch (error) {
-    }
-  }
-  const srcStat = await (dereference ? statAsync(src) : lstat(src)).catch((e) => {
-    if (e.code === "ENOENT") return null;
-    throw e;
-  });
-  if (!srcStat) {
-    throw new Error(`Source ${src} does not exist`);
-  }
-  if (srcStat.isDirectory()) {
-    if (!recursive) {
-      throw new Error(`Cannot copy directory ${src} without recursive flag`);
-    }
-    if (ensureDest) {
-      await mkdirs(dest);
-    }
-    const entries = await readdir(src, { withFileTypes: true });
-    for (const entry of entries) {
-      const srcPath = joinPath(src, entry.name);
-      const destPath = joinPath(dest, entry.name);
-      if (entry.isDirectory()) {
-        await copy(srcPath, destPath, options);
-      } else if (entry.isFile()) {
-        await copyFileAsync(srcPath, destPath, fsConstantsAsync.COPYFILE_FICLONE);
-      } else if (entry.isSymbolicLink()) {
-        const target = await readlink(srcPath);
-        await symlink(target, destPath);
-      }
-    }
-    if (verify && !await pathExists(dest)) {
-      throw new Error(`Copy operation failed: destination directory ${dest} does not exist after copy`);
-    }
-  } else {
-    if (ensureDest) {
-      await mkdirs(dirname(dest));
-    }
-    const destExists = await statAsync(dest).catch((e) => {
-      if (e.code === "ENOENT") return null;
-      throw e;
-    });
-    if (destExists) {
-      if (errorOnExist) {
-        throw new Error(`Destination ${dest} already exists.`);
-      }
-      if (!force && !overwrite) {
-        throw new Error(`Destination ${dest} already exists and overwrite is false.`);
-      }
-      if (force || overwrite) {
-        await rm(dest, { force: true });
-      }
-    }
-    await copyFileAsync(src, dest, fsConstantsAsync.COPYFILE_FICLONE);
-    if (verify && !await pathExists(dest)) {
-      throw new Error(`Copy operation failed: destination file ${dest} does not exist after copy`);
-    }
-  }
-}

package/bin/impl/create.d.ts

@@ -1,34 +0,0 @@
-export declare function createFileSync(file: string, content?: string): void;
-export declare function createFile(file: string, content?: string): Promise<void>;
-/**
- * Creates a single directory if it doesn't exist
- * @param dir Path to the directory to create
- */
-export declare function createDir(dir: string): Promise<void>;
-/**
- * Creates multiple directories if they don't exist
- * @param dirs Array of directory paths to create
- */
-export declare function createDirs(dirs: string[]): Promise<void>;
-/**
- * Creates multiple files with optional content
- * @param files Array of file paths to create
- * @param content Optional content to write to each file
- */
-export declare function createFiles(files: string[], content?: string): Promise<void>;
-/**
- * Synchronous version of createDir
- * @param dir Path to the directory to create
- */
-export declare function createDirSync(dir: string): void;
-/**
- * Synchronous version of createDirs
- * @param dirs Array of directory paths to create
- */
-export declare function createDirsSync(dirs: string[]): void;
-/**
- * Synchronous version of createFiles
- * @param files Array of file paths to create
- * @param content Optional content to write to each file
- */
-export declare function createFilesSync(files: string[], content?: string): void;

package/bin/impl/create.js

@@ -1,54 +0,0 @@
-import { existsSync, mkdirSync } from "node:fs";
-import { stat, mkdir } 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;
-  }
-}
-export async function createDir(dir) {
-  try {
-    await stat(dir);
-    return;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      await mkdir(dir, { recursive: true });
-    } else {
-      throw error;
-    }
-  }
-}
-export async function createDirs(dirs) {
-  await Promise.all(dirs.map((dir) => createDir(dir)));
-}
-export async function createFiles(files, content = "") {
-  await Promise.all(files.map((file) => createFile(file, content)));
-}
-export function createDirSync(dir) {
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-}
-export function createDirsSync(dirs) {
-  for (const dir of dirs) {
-    createDirSync(dir);
-  }
-}
-export function createFilesSync(files, content = "") {
-  for (const file of files) {
-    createFileSync(file, content);
-  }
-}

package/bin/impl/dive.d.ts

@@ -1,27 +0,0 @@
-import type { Stats } from "node:fs";
-import { statSync } from "node:fs";
-export interface DiveOptions {
-    all?: boolean;
-    recursive?: boolean;
-    directories?: boolean;
-    files?: boolean;
-    ignore?: string[] | RegExp;
-    depth?: number;
-}
-/**
- * Synchronously walks a directory and yields each file and/or directory path.
- *
- * @param dir - The directory to walk.
- * @param callbackOrOptions - A callback function to execute for each entry, or options object.
- * @param options - Options for the dive operation if a callback is provided as the second argument.
- */
-export declare function diveSync(dir: string, callbackOrOptions?: ((path: string, stat: ReturnType<typeof statSync>) => void) | DiveOptions, options?: DiveOptions): Generator<string, void, unknown>;
-/**
- * Recursively dives into a directory and yields files and directories.
- * @param directory - The directory to dive into.
- * @param action - An optional callback function to execute for each file or directory.
- * @param options - An optional object containing options for the dive.
- * @returns A Promise that resolves to an array of file paths if no action is provided, or void if an action is provided.
- */
-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[]>;