extra-fs/index.mjs

Useful additions to inbuilt fs module.

import { EOL } from 'os';
import { join } from 'path';
import * as F from 'fs';
export { Dir, Dirent, ReadStream, Stats, WriteStream, accessSync, appendFileSync, chmodSync, chownSync, closeSync, constants, copyFileSync, cpSync, createReadStream, createWriteStream, existsSync, fchmodSync, fchownSync, fdatasyncSync, fstatSync, fsyncSync, ftruncateSync, futimesSync, lchownSync, linkSync, lstatSync, lutimesSync, mkdirSync, mkdtempSync, openSync, opendirSync, readFileSync, readSync, readdirSync, readlinkSync, readvSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, symlinkSync, truncateSync, unlinkSync, unwatchFile, utimesSync, watch, watchFile, writeFileSync, writeSync, writevSync } from 'fs';
import * as P from 'fs/promises';
export { P as promises };
export { access as accessAsync, appendFile as appendFileAsync, chmod as chmodAsync, chown as chownAsync, copyFile as copyFileAsync, cp as cpAsync, lchown as lchownAsync, link as linkAsync, lstat as lstatAsync, lutimes as lutimesAsync, mkdir as mkdirAsync, mkdtemp as mkdtempAsync, open as openAsync, opendir as opendirAsync, readFile as readFileAsync, readdir as readdirAsync, readlink as readlinkAsync, realpath as realpathAsync, rename as renameAsync, rm as rmAsync, rmdir as rmdirAsync, stat as statAsync, symlink as symlinkAsync, truncate as truncateAsync, unlink as unlinkAsync, utimes as utimesAsync, writeFile as writeFileAsync } from 'fs/promises';

class FsError extends Error {
    constructor(code, message) {
        super(message);
        this.code = code;
        this.name = this.constructor.name;
    }
}
function open(...args) {
    if (typeof args[args.length - 1] === "function")
        F.open.apply(null, args);
    else
        return P.open.apply(null, args);
}
function closeAsync(fd) {
    return new Promise((resolve, reject) => {
        F.close(fd, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function close(...args) {
    if (typeof args[args.length - 1] === "function")
        F.close.apply(null, args);
    else
        return closeAsync.apply(null, args);
}
function readAsync(...args) {
    return new Promise((resolve, reject) => {
        F.read(...args, (err, bytesRead, buffer) => {
            if (err)
                reject(err);
            else
                resolve({ bytesRead, buffer });
        });
    });
}
function read(...args) {
    if (typeof args[args.length - 1] === "function")
        F.read.apply(null, args);
    else
        return readAsync.apply(null, args);
}
function writeAsync(...args) {
    return new Promise((resolve, reject) => {
        F.write(...args, (err, bytesWritten, buffer) => {
            if (err)
                reject(err);
            else
                resolve({ bytesWritten, buffer });
        });
    });
}
function write(...args) {
    if (typeof args[args.length - 1] === "function")
        F.write.apply(null, args);
    else
        return writeAsync.apply(null, args);
}
function readvAsync(fd, buffers, position) {
    return new Promise((resolve, reject) => {
        F.readv(fd, buffers, position, (err, bytesRead, buffers) => {
            if (err)
                reject(err);
            else
                resolve({ bytesRead, buffers });
        });
    });
}
function readv(...args) {
    if (typeof args[args.length - 1] === "function")
        F.readv.apply(null, args);
    else
        return readvAsync.apply(null, args);
}
function writevAsync(fd, buffers, position) {
    return new Promise((resolve, reject) => {
        F.writev(fd, buffers, position, (err, bytesWritten) => {
            if (err)
                reject(err);
            else
                resolve({ bytesWritten, buffers: buffers });
        });
    });
}
function writev(...args) {
    if (typeof args[args.length - 1] === "function")
        F.writev.apply(null, args);
    else
        return writevAsync.apply(null, args);
}
function fdatasyncAsync(fd) {
    return new Promise((resolve, reject) => {
        F.fdatasync(fd, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function fdatasync(...args) {
    if (typeof args[args.length - 1] === "function")
        F.fdatasync.apply(null, args);
    else
        return fdatasyncAsync.apply(null, args);
}
function fsyncAsync(fd) {
    return new Promise((resolve, reject) => {
        F.fsync(fd, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function fsync(...args) {
    if (typeof args[args.length - 1] === "function")
        F.fsync.apply(null, args);
    else
        return fsyncAsync.apply(null, args);
}
function ftruncateAsync(fd, len) {
    return new Promise((resolve, reject) => {
        F.ftruncate(fd, len, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function ftruncate(...args) {
    if (typeof args[args.length - 1] === "function")
        F.ftruncate.apply(null, args);
    else
        return ftruncateAsync.apply(null, args);
}
function futimesAsync(fd, atime, mtime) {
    return new Promise((resolve, reject) => {
        F.futimes(fd, atime, mtime, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function futimes(...args) {
    if (typeof args[args.length - 1] === "function")
        F.futimes.apply(null, args);
    else
        return futimesAsync.apply(null, args);
}
function fstatAsync(fd, options) {
    return new Promise((resolve, reject) => {
        F.fstat(fd, options, (err, stats) => {
            if (err)
                reject(err);
            else
                resolve(stats);
        });
    });
}
function fstat(...args) {
    if (typeof args[args.length - 1] === "function")
        F.fstat.apply(null, args);
    else
        return fstatAsync.apply(null, args);
}
function fchmodAsync(fd, mode) {
    return new Promise((resolve, reject) => {
        F.fchmod(fd, mode, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function fchmod(...args) {
    if (typeof args[args.length - 1] === "function")
        F.fchmod.apply(null, args);
    else
        return fchmodAsync.apply(null, args);
}
function fchownAsync(fd, uid, gid) {
    return new Promise((resolve, reject) => {
        F.fchown(fd, uid, gid, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function fchown(...args) {
    if (typeof args[args.length - 1] === "function")
        F.fchown.apply(null, args);
    else
        return fchownAsync.apply(null, args);
}
function link(...args) {
    if (typeof args[args.length - 1] === "function")
        F.link.apply(null, args);
    else
        return P.link.apply(null, args);
}
function symlink(...args) {
    if (typeof args[args.length - 1] === "function")
        F.symlink.apply(null, args);
    else
        return P.symlink.apply(null, args);
}
function readlink(...args) {
    if (typeof args[args.length - 1] === "function")
        F.readlink.apply(null, args);
    else
        return P.readlink.apply(null, args);
}
function realpath(...args) {
    if (typeof args[args.length - 1] === "function")
        F.realpath.apply(null, args);
    else
        return P.realpath.apply(null, args);
}
function lutimes(...args) {
    if (typeof args[args.length - 1] === "function")
        F.lutimes.apply(null, args);
    else
        return P.lutimes.apply(null, args);
}
function lstat(...args) {
    if (typeof args[args.length - 1] === "function")
        F.lstat.apply(null, args);
    else
        return P.lstat.apply(null, args);
}
function lchown(...args) {
    if (typeof args[args.length - 1] === "function")
        F.lchown.apply(null, args);
    else
        return P.lchown.apply(null, args);
}
function readFile(...args) {
    if (typeof args[args.length - 1] === "function")
        F.readFile.apply(null, args);
    else
        return P.readFile.apply(null, args);
}
function writeFile(...args) {
    if (typeof args[args.length - 1] === "function")
        F.writeFile.apply(null, args);
    else
        return P.writeFile.apply(null, args);
}
function appendFile(...args) {
    if (typeof args[args.length - 1] === "function")
        F.appendFile.apply(null, args);
    else
        return P.appendFile.apply(null, args);
}
function truncate(...args) {
    if (typeof args[args.length - 1] === "function")
        F.truncate.apply(null, args);
    else
        return P.truncate.apply(null, args);
}
function unlink(...args) {
    if (typeof args[args.length - 1] === "function")
        F.unlink.apply(null, args);
    else
        return P.unlink.apply(null, args);
}
function utimes(...args) {
    if (typeof args[args.length - 1] === "function")
        F.utimes.apply(null, args);
    else
        return P.utimes.apply(null, args);
}
function stat(...args) {
    if (typeof args[args.length - 1] === "function")
        F.stat.apply(null, args);
    else
        return P.stat.apply(null, args);
}
function copyFile(...args) {
    if (typeof args[args.length - 1] === "function")
        F.copyFile.apply(null, args);
    else
        return P.copyFile.apply(null, args);
}
function mkdir(...args) {
    if (typeof args[args.length - 1] === "function")
        F.mkdir.apply(null, args);
    else
        return P.mkdir.apply(null, args);
}
function mkdtemp(...args) {
    if (typeof args[args.length - 1] === "function")
        F.mkdtemp.apply(null, args);
    else
        return P.mkdtemp.apply(null, args);
}
function opendir(...args) {
    if (typeof args[args.length - 1] === "function")
        F.opendir.apply(null, args);
    else
        return P.opendir.apply(null, args);
}
function readdir(...args) {
    if (typeof args[args.length - 1] === "function")
        F.readdir.apply(null, args);
    else
        return P.readdir.apply(null, args);
}
function rmdir(...args) {
    if (typeof args[args.length - 1] === "function")
        F.rm.apply(null, args);
    else
        return P.rm.apply(null, args);
}
function access(...args) {
    if (typeof args[args.length - 1] === "function")
        F.access.apply(null, args);
    else
        return P.access.apply(null, args);
}
function chmod(...args) {
    if (typeof args[args.length - 1] === "function")
        F.chmod.apply(null, args);
    else
        return P.chmod.apply(null, args);
}
function chown(...args) {
    if (typeof args[args.length - 1] === "function")
        F.chown.apply(null, args);
    else
        return P.chown.apply(null, args);
}
function rename(...args) {
    if (typeof args[args.length - 1] === "function")
        F.rename.apply(null, args);
    else
        return P.rename.apply(null, args);
}
function cp(...args) {
    if (typeof args[args.length - 1] === "function")
        F.cp.apply(null, args);
    else
        return P.cp.apply(null, args);
}
function rm(...args) {
    if (typeof args[args.length - 1] === "function")
        F.rm.apply(null, args);
    else
        return P.rm.apply(null, args);
}
async function readFileTextAsync(path) {
    var text = await P.readFile(path, "utf8");
    return text.replace(/\r?\n/g, "\n");
}
function readFileTextSync(path) {
    var text = F.readFileSync(path, "utf8");
    return text.replace(/\r?\n/g, "\n");
}
function readFileTextCb(path, fn) {
    F.readFile(path, "utf8", (err, text) => {
        if (err)
            return fn(err);
        fn(null, text.replace(/\r?\n/g, "\n"));
    });
}
function readFileText(...args) {
    if (typeof args[args.length - 1] === "function")
        readFileTextCb.apply(null, args);
    else
        return readFileTextAsync.apply(null, args);
}
function writeFileTextAsync(path, text) {
    var text = text.replace(/\r?\n/g, EOL);
    return P.writeFile(path, text);
}
function writeFileTextSync(path, text) {
    var text = text.replace(/\r?\n/g, EOL);
    return F.writeFileSync(path, text);
}
function writeFileTextCb(path, text, fn) {
    var text = text.replace(/\r?\n/g, EOL);
    F.writeFile(path, text, fn);
}
function writeFileText(...args) {
    if (typeof args[args.length - 1] === "function")
        writeFileTextCb.apply(null, args);
    else
        return writeFileTextAsync.apply(null, args);
}
async function readJsonAsync(path) {
    return JSON.parse(await readFileTextAsync(path));
}
function readJsonSync(path) {
    return JSON.parse(readFileTextSync(path));
}
function readJsonCb(path, fn) {
    readFileTextCb(path, (err, text) => {
        if (err != null)
            return fn(err);
        fn(null, JSON.parse(text));
    });
}
function readJson(...args) {
    if (typeof args[args.length - 1] === "function")
        readJsonCb.apply(null, args);
    else
        return readJsonAsync.apply(null, args);
}
function writeJsonAsync(path, json) {
    return writeFileTextAsync(path, JSON.stringify(json, null, 2) + "\n");
}
function writeJsonSync(path, json) {
    writeFileTextSync(path, JSON.stringify(json, null, 2) + "\n");
}
function writeJsonCb(path, json, fn) {
    writeFileText(path, JSON.stringify(json, null, 2) + "\n", fn);
}
function writeJson(...args) {
    if (typeof args[args.length - 1] === "function")
        writeJsonCb.apply(null, args);
    else
        return writeJsonAsync.apply(null, args);
}
function dehuskdirSync(dir, depth = -1) {
    for (var seed = dir; depth > 0; depth--) {
        var es = F.readdirSync(seed, { withFileTypes: true });
        if (es.length === 0 || es.length > 1 || !es[0].isDirectory())
            break;
        seed = join(seed, es[0].name);
    }
    if (seed === dir)
        return seed;
    var tmp = dir + Math.random();
    F.renameSync(seed, tmp);
    F.rmdirSync(dir);
    F.renameSync(tmp, dir);
    return seed;
}
async function dehuskdirAsync(dir, depth = -1) {
    for (var seed = dir; depth > 0; depth--) {
        var es = await P.readdir(seed, { withFileTypes: true });
        if (es.length === 0 || es.length > 1 || !es[0].isDirectory())
            break;
        seed = join(seed, es[0].name);
    }
    if (seed === dir)
        return seed;
    var tmp = dir + Math.random();
    await P.rename(seed, tmp);
    await P.rmdir(dir);
    await P.rename(tmp, dir);
    return seed;
}
function dehuskdirCb(...args) {
    var dir = args[0];
    var depth = typeof args[1] === "number" ? args[1] : 0;
    var fn = args[args.length - 1];
    dehuskdirAsync(dir, depth).then(seed => fn(seed), fn);
}
function dehuskdir(...args) {
    if (typeof args[args.length - 1] === "function")
        dehuskdirCb.apply(null, args);
    else
        return dehuskdirAsync.apply(null, args);
}
async function existsAsync(path) {
    try {
        await P.access(path);
        return true;
    }
    catch (_a) {
        return false;
    }
}
function exists(path, fn) {
    if (typeof fn === "function")
        existsAsync(path).then(a => fn(null, a), fn);
    else
        return existsAsync(path);
}
async function assertExistsAsync(path) {
    await P.access(path);
}
function assertExistsSync(path) {
    F.accessSync(path);
}
function assertExists(...args) {
    if (typeof args[args.length - 1] === "function")
        F.access.apply(null, args);
    else
        return assertExistsAsync.apply(null, args);
}
async function assertNotExistsAsync(path, err) {
    try {
        await P.access(path);
    }
    catch (_a) {
        return;
    }
    var message = `file or directory already exists, path "${path}"`;
    throw new FsError(err || "ERR_FS_ENSURE_NOT_EXISTS", message);
}
function assertNotExistsSync(path, err) {
    try {
        F.accessSync(path);
    }
    catch (_a) {
        return;
    }
    var message = `file or directory already exists, path "${path}"`;
    throw new FsError(err || "ERR_FS_ENSURE_NOT_EXISTS", message);
}
function assertNotExistsCb(path, err, fn) {
    var _fn = arguments.length === 3 ? fn : err;
    var _err = arguments.length === 3 ? err : null;
    F.access(path, e => {
        if (e != null)
            return _fn(null);
        var message = `file or directory already exists, path "${path}"`;
        _fn(new FsError(_err || "ERR_FS_ENSURE_NOT_EXISTS", message));
    });
}
function assertNotExists(...args) {
    if (typeof args[args.length - 1] === "function")
        assertNotExistsCb.apply(null, args);
    else
        return assertNotExistsAsync.apply(null, args);
}

export { FsError, access, appendFile, assertExists, assertExistsAsync, assertExistsSync, assertNotExists, assertNotExistsAsync, assertNotExistsSync, chmod, chown, close, closeAsync, copyFile, cp, dehuskdir, dehuskdirAsync, dehuskdirSync, exists, existsAsync, fchmod, fchmodAsync, fchown, fchownAsync, fdatasync, fdatasyncAsync, fstat, fstatAsync, fsync, fsyncAsync, ftruncate, ftruncateAsync, futimes, futimesAsync, lchown, link, lstat, lutimes, mkdir, mkdtemp, open, opendir, read, readAsync, readFile, readFileText, readFileTextAsync, readFileTextSync, readJson, readJsonAsync, readJsonSync, readdir, readlink, readv, readvAsync, realpath, rename, rm, rmdir, stat, symlink, truncate, unlink, utimes, write, writeAsync, writeFile, writeFileText, writeFileTextAsync, writeFileTextSync, writeJson, writeJsonAsync, writeJsonSync, writev, writevAsync };