@reliverse/relifso 1.0.0

package/bin/impl/lib/index.js

@@ -0,0 +1,34 @@
+export * from "../fs/index.js";
+export * from "./copy/index.js";
+export * from "./empty/index.js";
+export * from "./ensure/index.js";
+export * from "../json.js";
+export * from "./mkdirs/index.js";
+export * from "./move/index.js";
+export * from "./output-file/index.js";
+export * from "./remove/index.js";
+export { exists } from "../fs/exists.js";
+export { existsSync as pathExistsSync } from "../fs/index.js";
+export { exists as pathExists } from "../fs/exists.js";
+export {
+  readJson as readJSON,
+  readJsonSync as readJSONSync,
+  writeJson as writeJSON,
+  writeJsonSync as writeJSONSync,
+  outputJson as outputJSON,
+  outputJsonSync as outputJSONSync
+} from "../json.js";
+export {
+  mkdirs as mkdirp,
+  mkdirsSync as mkdirpSync,
+  mkdirs as ensureDir,
+  mkdirsSync as ensureDirSync
+} from "./mkdirs/index.js";
+export {
+  ensureFile as createFile,
+  ensureFileSync as createFileSync,
+  ensureLink as createLink,
+  ensureLinkSync as createLinkSync,
+  ensureSymlink as createSymlink,
+  ensureSymlinkSync as createSymlinkSync
+} from "./ensure/index.js";

package/bin/impl/lib/index_rollup.d.ts

@@ -0,0 +1,10 @@
+export * from "../fs/index.js";
+export * from "./copy/index.js";
+export * from "./empty/index.js";
+export * from "./ensure/index.js";
+export * from "../json.js";
+export * from "./mkdirs/index.js";
+export * from "./move/index.js";
+export * from "./output-file/index.js";
+export * from "./remove/index.js";
+export { exists } from "../fs/exists.js";

package/bin/impl/lib/index_rollup.js

@@ -0,0 +1,10 @@
+export * from "../fs/index.js";
+export * from "./copy/index.js";
+export * from "./empty/index.js";
+export * from "./ensure/index.js";
+export * from "../json.js";
+export * from "./mkdirs/index.js";
+export * from "./move/index.js";
+export * from "./output-file/index.js";
+export * from "./remove/index.js";
+export { exists } from "../fs/exists.js";

package/bin/impl/lib/json/index.d.ts

@@ -0,0 +1,3 @@
+export { writeFile as writeJson, writeFileSync as writeJsonSync, readFile as readJson, readFileSync as readJsonSync, } from "jsonfile";
+export declare const outputJson: (...args: any[]) => Promise<any> | void;
+export { default as outputJsonSync } from "./output-json-sync.js";

package/bin/impl/lib/json/index.js

@@ -0,0 +1,10 @@
+import { fromPromise as u } from "universalify";
+export {
+  writeFile as writeJson,
+  writeFileSync as writeJsonSync,
+  readFile as readJson,
+  readFileSync as readJsonSync
+} from "jsonfile";
+import _outputJson from "./output-json.js";
+export const outputJson = u(_outputJson);
+export { default as outputJsonSync } from "./output-json-sync.js";

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

@@ -0,0 +1 @@
+export default function outputJsonSync(file: any, data: any, options: any): void;

package/bin/impl/lib/json/output-json-sync.js

@@ -0,0 +1,6 @@
+import { stringify } from "jsonfile/utils.js";
+import { outputFileSync } from "../output-file/index.js";
+export default function outputJsonSync(file, data, options) {
+  const str = stringify(data, options);
+  outputFileSync(file, str, options);
+}

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

@@ -0,0 +1 @@
+export default function outputJson(file: any, data: any, options?: {}): Promise<void>;

package/bin/impl/lib/json/output-json.js

@@ -0,0 +1,6 @@
+import { stringify } from "jsonfile/utils.js";
+import { outputFile } from "../output-file/index.js";
+export default async function outputJson(file, data, options = {}) {
+  const str = stringify(data, options);
+  await outputFile(file, str, options);
+}

package/bin/impl/lib/mkdirs/index.d.ts

@@ -0,0 +1 @@
+export { ensureDir as mkdirs, ensureDirSync as mkdirsSync } from "fs-extra";

package/bin/impl/lib/mkdirs/index.js

@@ -0,0 +1,4 @@
+import { fromPromise as u } from "universalify";
+import { makeDir as _makeDir } from "./make-dir.js";
+export { makeDirSync as mkdirsSync } from "./make-dir.js";
+export const mkdirs = u(_makeDir);

package/bin/impl/lib/mkdirs/make-dir.d.ts

@@ -0,0 +1,2 @@
+export declare function makeDir(dir: any, options: any): Promise<any>;
+export declare function makeDirSync(dir: any, options: any): any;

package/bin/impl/lib/mkdirs/make-dir.js

@@ -0,0 +1,21 @@
+import { mkdir, mkdirSync } from "../../fs/index.js";
+import { checkPath } from "./utils.js";
+const getMode = (options) => {
+  const defaults = { mode: 511 };
+  if (typeof options === "number") return options;
+  return { ...defaults, ...options }.mode;
+};
+export async function makeDir(dir, options) {
+  checkPath(dir);
+  return mkdir(dir, {
+    mode: getMode(options),
+    recursive: true
+  });
+}
+export function makeDirSync(dir, options) {
+  checkPath(dir);
+  return mkdirSync(dir, {
+    mode: getMode(options),
+    recursive: true
+  });
+}

package/bin/impl/lib/mkdirs/utils.d.ts

@@ -0,0 +1 @@
+export declare function checkPath(pth: any): void;

package/bin/impl/lib/mkdirs/utils.js

@@ -0,0 +1,13 @@
+import { parse } from "node:path";
+export function checkPath(pth) {
+  if (process.platform === "win32") {
+    const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(
+      pth.replace(parse(pth).root, "")
+    );
+    if (pathHasInvalidWinCharacters) {
+      const error = new Error(`Path contains invalid characters: ${pth}`);
+      error.code = "EINVAL";
+      throw error;
+    }
+  }
+}

package/bin/impl/lib/move/index.d.ts

@@ -0,0 +1,30 @@
+export { moveSync } from "fs-extra";
+import type { NoParamCallbackWithUndefined } from "fs-extra";
+
+interface MoveOptions {
+  overwrite?: boolean;
+  clobber?: boolean;
+}
+
+export function move(
+  src: string,
+  dest: string,
+  options: undefined,
+  callback: NoParamCallbackWithUndefined,
+): void;
+export function move(
+  src: string,
+  dest: string,
+  options?: MoveOptions,
+): Promise<void>;
+export function move(
+  src: string,
+  dest: string,
+  callback: NoParamCallbackWithUndefined,
+): void;
+export function move(
+  src: string,
+  dest: string,
+  options: MoveOptions,
+  callback: NoParamCallbackWithUndefined,
+): void;

package/bin/impl/lib/move/index.js

@@ -0,0 +1,2 @@
+export { default as move } from "./move.js";
+export { default as moveSync } from "./move-sync.js";

package/bin/impl/lib/move/move-sync.d.ts

@@ -0,0 +1,8 @@
+export interface MoveOptions {
+    /** Overwrite destination if it exists */
+    overwrite?: boolean;
+    /** Legacy alias for `overwrite`. */
+    clobber?: boolean;
+}
+export declare function moveSync(src: string, dest: string, options?: MoveOptions): void;
+export default moveSync;

package/bin/impl/lib/move/move-sync.js

@@ -0,0 +1,51 @@
+import { existsSync, renameSync } from "graceful-fs";
+import { dirname, parse } from "node:path";
+import { copySync } from "../copy/index.js";
+import { mkdirsSync } from "../mkdirs/index.js";
+import { removeSync } from "../remove/index.js";
+import {
+  checkParentPathsSync,
+  checkPathsSync
+} from "../util/stat.js";
+export function moveSync(src, dest, options = {}) {
+  const overwrite = options.overwrite ?? options.clobber ?? false;
+  const { srcStat, isChangingCase = false } = checkPathsSync(
+    src,
+    dest,
+    "move",
+    options
+  );
+  checkParentPathsSync(src, srcStat, dest, "move");
+  if (!isRootDir(dirname(dest))) {
+    mkdirsSync(dirname(dest), {});
+  }
+  if (isChangingCase) {
+    attemptRename(src, dest, overwrite);
+    return;
+  }
+  if (overwrite) {
+    removeSync(dest);
+  } else if (existsSync(dest)) {
+    throw new Error(`'${dest}' already exists`);
+  }
+  attemptRename(src, dest, overwrite);
+}
+export default moveSync;
+const isRootDir = (p) => parse(p).root === p;
+function attemptRename(src, dest, overwrite) {
+  try {
+    renameSync(src, dest);
+  } catch (err) {
+    const e = err;
+    if (e.code !== "EXDEV") throw err;
+    moveAcrossDevices(src, dest, overwrite);
+  }
+}
+function moveAcrossDevices(src, dest, overwrite) {
+  copySync(src, dest, {
+    overwrite,
+    preserveTimestamps: true,
+    errorOnExist: true
+  });
+  removeSync(src);
+}

package/bin/impl/lib/move/move.d.ts

@@ -0,0 +1,6 @@
+export interface MoveOptions {
+    overwrite?: boolean;
+    clobber?: boolean;
+}
+declare const _default: (...args: any[]) => Promise<any> | void;
+export default _default;

package/bin/impl/lib/move/move.js

@@ -0,0 +1,48 @@
+import { dirname, parse } from "node:path";
+import { fromPromise } from "universalify";
+import { exists as pathExists } from "../../fs/exists.js";
+import { rename as _rename } from "../../fs/index.js";
+import { copy } from "../copy/index.js";
+import { mkdirs } from "../mkdirs/index.js";
+import { remove } from "../remove/index.js";
+import * as stat from "../util/stat.js";
+async function _move(src, dest, opts = {}) {
+  const overwrite = opts.overwrite ?? opts.clobber ?? false;
+  const { srcStat, isChangingCase = false } = await stat.checkPaths(
+    src,
+    dest,
+    "move",
+    opts
+  );
+  await stat.checkParentPaths(src, srcStat, dest, "move");
+  const parent = dirname(dest);
+  if (parse(parent).root !== parent) {
+    await mkdirs(parent);
+  }
+  await doRename(src, dest, overwrite, isChangingCase);
+}
+export default fromPromise(_move);
+async function doRename(src, dest, overwrite, isChangingCase) {
+  if (!isChangingCase) {
+    if (overwrite) {
+      await remove(dest);
+    } else if (await pathExists(dest)) {
+      throw new Error(`'${dest}' already exists`);
+    }
+  }
+  try {
+    await _rename(src, dest);
+  } catch (err) {
+    const e = err;
+    if (e.code !== "EXDEV") throw err;
+    await moveAcrossDevices(src, dest, overwrite);
+  }
+}
+async function moveAcrossDevices(src, dest, overwrite) {
+  await copy(src, dest, {
+    overwrite,
+    errorOnExist: true,
+    preserveTimestamps: true
+  });
+  await remove(src);
+}

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

@@ -0,0 +1 @@
+export { outputFile, outputFileSync } from "fs-extra";

package/bin/impl/lib/output-file/index.js

@@ -0,0 +1,24 @@
+import { dirname } from "node:path";
+import { fromPromise } from "universalify";
+import { exists as pathExists } from "../../fs/exists.js";
+import {
+  writeFile,
+  existsSync,
+  writeFileSync
+} from "../../fs/index.js";
+import { mkdirs, mkdirsSync } from "../mkdirs/index.js";
+async function _outputFile(file, data, encoding = "utf-8") {
+  const dir = dirname(file);
+  if (!await pathExists(dir)) {
+    await mkdirs(dir);
+  }
+  return writeFile(file, data, encoding);
+}
+export const outputFile = fromPromise(_outputFile);
+export function outputFileSync(file, ...args) {
+  const dir = dirname(file);
+  if (!existsSync(dir)) {
+    mkdirsSync(dir);
+  }
+  writeFileSync(file, ...args);
+}

package/bin/impl/lib/remove/index.d.ts

@@ -0,0 +1,53 @@
+import { type PathLike } from "../../fs/index.js";
+/**
+ * Removes a file or directory. The directory can have contents. If the path does not exist, silently does nothing.
+ *
+ * @example
+ * import * as fs from 'fs-extra'
+ *
+ * // remove file
+ * // With a callback:
+ * fs.remove('/tmp/myfile', err => {
+ *   if (err) return console.error(err)
+ *   console.log('success!')
+ * })
+ *
+ * fs.remove('/home/jprichardson', err => {
+ *   if (err) return console.error(err)
+ *   console.log('success!') // I just deleted my entire HOME directory.
+ * })
+ *
+ * // With Promises:
+ * fs.remove('/tmp/myfile')
+ *   .then(() => {
+ *     console.log('success!')
+ *   })
+ *   .catch(err => {
+ *     console.error(err)
+ *   })
+ *
+ * // With async/await:
+ * async function asyncAwait () {
+ *   try {
+ *     await fs.remove('/tmp/myfile')
+ *     console.log('success!')
+ *   } catch (err) {
+ *     console.error(err)
+ *   }
+ * }
+ *
+ * asyncAwait()
+ */
+export declare const remove: (...args: any[]) => Promise<any> | void;
+/**
+ * Removes a file or directory. The directory can have contents. If the path does not exist, silently does nothing.
+ *
+ * @example
+ * import * as fs from 'fs-extra'
+ *
+ * // remove file
+ * fs.removeSync('/tmp/myfile')
+ *
+ * fs.removeSync('/home/jprichardson') // I just deleted my entire HOME directory.
+ */
+export declare function removeSync(path: PathLike): void;

package/bin/impl/lib/remove/index.js

@@ -0,0 +1,8 @@
+import { fromPromise } from "universalify";
+import { rm, rmSync } from "../../fs/index.js";
+export const remove = fromPromise(function remove2(path) {
+  return rm(path, { recursive: true, force: true });
+});
+export function removeSync(path) {
+  rmSync(path, { recursive: true, force: true });
+}

package/bin/impl/lib/util/stat.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @param {string} src
+ * @param {string} dest
+ * @param {string} funcName
+ * @param {{ dereference?: boolean }} opts
+ */
+export declare function checkPathsSync(src: any, dest: any, funcName: any, opts: any): {
+    srcStat: any;
+    destStat: any;
+    isChangingCase: boolean;
+} | {
+    srcStat: any;
+    destStat: any;
+    isChangingCase?: undefined;
+};
+/**
+ *
+ * @param {string} src
+ * @param {import('fs').BigIntStats} srcStat
+ * @param {string} dest
+ * @param {string} funcName
+ * @returns
+ */
+export declare function checkParentPathsSync(src: any, srcStat: any, dest: any, funcName: any): void;
+/**
+ *
+ * @param {import('fs').BigIntStats} srcStat
+ * @param {import('fs').BigIntStats} destStat
+ * @returns {boolean}
+ */
+export declare function areIdentical(srcStat: any, destStat: any): boolean;
+/**
+ * @param {string} src
+ * @param {string} dest
+ * @returns
+ */
+export declare function isSrcSubdir(src: any, dest: any): boolean;
+export declare const checkPaths: (...args: any[]) => Promise<any> | void;
+export declare const checkParentPaths: (...args: any[]) => Promise<any> | void;

package/bin/impl/lib/util/stat.js

@@ -0,0 +1,140 @@
+import { basename, resolve, dirname, parse, sep } from "node:path";
+import { fromPromise } from "universalify";
+import {
+  stat,
+  lstat,
+  statSync,
+  lstatSync
+} from "../../fs/index.js";
+async function getStats(src, dest, opts) {
+  const statFunc = opts.dereference ? (file) => stat(file, { bigint: true }) : (file) => lstat(file, { bigint: true });
+  const [srcStat, destStat] = await Promise.all([
+    statFunc(src),
+    statFunc(dest).catch((err) => {
+      if (err.code === "ENOENT") return null;
+      throw err;
+    })
+  ]);
+  return { srcStat, destStat };
+}
+function getStatsSync(src, dest, opts) {
+  let destStat;
+  const statFunc = opts.dereference ? (file) => statSync(file, { bigint: true }) : (file) => lstatSync(file, { bigint: true });
+  const srcStat = statFunc(src);
+  try {
+    destStat = statFunc(dest);
+  } catch (err) {
+    if (
+      /** @type {NodeJS.ErrnoException} */
+      err.code === "ENOENT"
+    )
+      return { srcStat, destStat: null };
+    throw err;
+  }
+  return { srcStat, destStat };
+}
+async function _checkPaths(src, dest, funcName, opts) {
+  const { srcStat, destStat } = await getStats(src, dest, opts);
+  if (destStat) {
+    if (areIdentical(srcStat, destStat)) {
+      const srcBaseName = basename(src);
+      const destBaseName = basename(dest);
+      if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+        return { srcStat, destStat, isChangingCase: true };
+      }
+      throw new Error("Source and destination must not be the same.");
+    }
+    if (srcStat.isDirectory() && !destStat.isDirectory()) {
+      throw new Error(
+        `Cannot overwrite non-directory '${dest}' with directory '${src}'.`
+      );
+    }
+    if (!srcStat.isDirectory() && destStat.isDirectory()) {
+      throw new Error(
+        `Cannot overwrite directory '${dest}' with non-directory '${src}'.`
+      );
+    }
+  }
+  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+    throw new Error(errMsg(src, dest, funcName));
+  }
+  return { srcStat, destStat };
+}
+export function checkPathsSync(src, dest, funcName, opts) {
+  const { srcStat, destStat } = getStatsSync(src, dest, opts);
+  if (destStat) {
+    if (areIdentical(srcStat, destStat)) {
+      const srcBaseName = basename(src);
+      const destBaseName = basename(dest);
+      if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+        return { srcStat, destStat, isChangingCase: true };
+      }
+      throw new Error("Source and destination must not be the same.");
+    }
+    if (srcStat.isDirectory() && !destStat.isDirectory()) {
+      throw new Error(
+        `Cannot overwrite non-directory '${dest}' with directory '${src}'.`
+      );
+    }
+    if (!srcStat.isDirectory() && destStat.isDirectory()) {
+      throw new Error(
+        `Cannot overwrite directory '${dest}' with non-directory '${src}'.`
+      );
+    }
+  }
+  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+    throw new Error(errMsg(src, dest, funcName));
+  }
+  return { srcStat, destStat };
+}
+async function _checkParentPaths(src, srcStat, dest, funcName) {
+  const srcParent = resolve(dirname(src));
+  const destParent = resolve(dirname(dest));
+  if (destParent === srcParent || destParent === parse(destParent).root) return;
+  let destStat;
+  try {
+    destStat = await stat(destParent, { bigint: true });
+  } catch (err) {
+    if (
+      /** @type {NodeJS.ErrnoException} */
+      err.code === "ENOENT"
+    ) return;
+    throw err;
+  }
+  if (areIdentical(srcStat, destStat)) {
+    throw new Error(errMsg(src, dest, funcName));
+  }
+  return checkParentPaths(src, srcStat, destParent, funcName);
+}
+export function checkParentPathsSync(src, srcStat, dest, funcName) {
+  const srcParent = resolve(dirname(src));
+  const destParent = resolve(dirname(dest));
+  if (destParent === srcParent || destParent === parse(destParent).root) return;
+  let destStat;
+  try {
+    destStat = statSync(destParent, { bigint: true });
+  } catch (err) {
+    if (
+      /** @type {NodeJS.ErrnoException} */
+      err.code === "ENOENT"
+    ) return;
+    throw err;
+  }
+  if (areIdentical(srcStat, destStat)) {
+    throw new Error(errMsg(src, dest, funcName));
+  }
+  return checkParentPathsSync(src, srcStat, destParent, funcName);
+}
+export function areIdentical(srcStat, destStat) {
+  return !!destStat.ino && !!destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
+}
+export function isSrcSubdir(src, dest) {
+  const srcArr = resolve(src).split(sep).filter((i) => i);
+  const destArr = resolve(dest).split(sep).filter((i) => i);
+  return srcArr.every((cur, i) => destArr[i] === cur);
+}
+function errMsg(src, dest, funcName) {
+  return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+}
+export const checkPaths = fromPromise(_checkPaths);
+export const checkParentPaths = fromPromise(_checkParentPaths);

package/bin/impl/lib/util/utimes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {import("fs").PathLike} path
+ * @param {import("fs").TimeLike} atime
+ * @param {import("fs").TimeLike} mtime
+ */
+export declare function utimesMillisSync(path: any, atime: any, mtime: any): any;
+export declare const utimesMillis: (...args: any[]) => Promise<any> | void;

package/bin/impl/lib/util/utimes.js

@@ -0,0 +1,31 @@
+import { fromPromise } from "universalify";
+import {
+  futimes,
+  open,
+  close,
+  openSync,
+  futimesSync,
+  closeSync
+} from "../../fs/index.js";
+async function _utimesMillis(path, atime, mtime) {
+  const fd = await open(path, "r+");
+  let closeErr = null;
+  try {
+    await futimes(fd, atime, mtime);
+  } finally {
+    try {
+      await close(fd);
+    } catch (e) {
+      closeErr = e;
+    }
+  }
+  if (closeErr) {
+    throw closeErr;
+  }
+}
+export function utimesMillisSync(path, atime, mtime) {
+  const fd = openSync(path, "r+");
+  futimesSync(fd, atime, mtime);
+  return closeSync(fd);
+}
+export const utimesMillis = fromPromise(_utimesMillis);

package/bin/impl/subindex.d.ts

@@ -0,0 +1,37 @@
+export type * from "../types.js";
+export type { CopyOptions, CopyOptionsSync, EnsureDirOptions, SymlinkType, MoveOptions, JsonOutputOptions, } from "fs-extra";
+export * from "./fs/index.js";
+export { default as vacuum } from "./external/vacuum.js";
+export { copy, copySync } from "./lib/copy/index.js";
+export { emptyDir, emptyDirSync } from "./lib/empty/index.js";
+export { ensureFile, ensureFileSync, ensureLink, ensureLinkSync, ensureSymlink, ensureSymlinkSync, } from "./lib/ensure/index.js";
+export { mkdirs, mkdirsSync, mkdirs as ensureDir, mkdirsSync as ensureDirSync, } from "./lib/mkdirs/index.js";
+export { move, moveSync } from "./lib/move/index.js";
+export { outputFile, outputFileSync } from "./lib/output-file/index.js";
+export { remove, removeSync } from "./lib/remove/index.js";
+export { exists, exists as pathExists } from "./fs/exists.js";
+export { dive, diveSync } from "./fs/dive.js";
+export { forEachChild, forEachChildSync } from "./fs/for-each-child.js";
+export { isDirectory, isDirectorySync } from "./fs/is-directory.js";
+export { mapChildren } from "./fs/map-children.js";
+export { mapStructure, mapStructureOrdered } from "./fs/map-structure.js";
+export { readLines, readLinesSync } from "./fs/read-lines.js";
+export { readText, readTextSync } from "./fs/read-text.js";
+export { writeFile } from "./fs/write-file.js";
+export * from "./json.js";
+/**
+ * Resolve a child file of a folder.
+ * @param path The parent folder path
+ * @param child The child filesystem entry path (can be a file or folder)
+ * @returns `path` and `child` concatenated, delimited by whatever path separator is already used in the string,
+ * defaulting to `/`; a delimiter is never added if it's not necessary.
+ */
+export declare function resolve(path: string, child: string): string;
+/**
+ * Check if the file at a path is a symbolic link.
+ * @param path the path to the file to check
+ * @param callback callback function to call with whether or not the file is a symbolic link, or a value for `err` if the
+ * operation fails
+ */
+export declare function isSymlink(file: string): Promise<boolean>;
+export declare function isSymlink(file: string, callback?: (err: NodeJS.ErrnoException | null, isSymblink?: boolean) => void): void;