pwd-fs 2.4.1 → 3.1.3

package/lib/powered-file-system.js

@@ -0,0 +1,260 @@
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+var recurseIo = require('./recurse-io.js');
+var recurseIoSync = require('./recurse-io-sync.js');
+
+const permissions = [
+    0o400, // OWNER_READ
+    0o200, // OWNER_WRITE
+    0o100, // OWNER_EXECUTE
+    0o040, // GROUP_READ
+    0o020, // GROUP_WRITE
+    0o010, // GROUP_EXECUTE
+    0o004, // OTHERS_READ
+    0o002, // OTHERS_WRITE
+    0o001 // OTHERS_EXECUTE
+];
+class PoweredFileSystem {
+    pwd;
+    constants = {
+        e: fs.constants.F_OK,
+        r: fs.constants.R_OK,
+        w: fs.constants.W_OK,
+        x: fs.constants.X_OK
+    };
+    constructor(pwd) {
+        this.pwd = pwd ? path.resolve(pwd) : process.cwd();
+    }
+    resolve(src) {
+        return path.resolve(this.pwd, src);
+    }
+    static bitmask(mode) {
+        const type = typeof mode;
+        if (type !== 'number') {
+            throw new Error(`Argument of type '${type}' is not assignable to parameter of type 'number'.`);
+        }
+        let umask = 0o000;
+        for (const flag of permissions) {
+            if (mode & flag) {
+                umask += flag;
+            }
+        }
+        return umask;
+    }
+    test(src, { sync = false, flag = 'e' } = {}) {
+        const mode = this.constants[flag];
+        src = path.resolve(this.pwd, src);
+        if (sync) {
+            return fs.existsSync(src);
+        }
+        return new Promise((resolve) => {
+            fs.access(src, mode, (err) => {
+                if (err) {
+                    return resolve(false);
+                }
+                resolve(true);
+            });
+        });
+    }
+    stat(src, { sync = false } = {}) {
+        src = this.resolve(src);
+        if (sync) {
+            return fs.lstatSync(src);
+        }
+        return new Promise((resolve, reject) => {
+            fs.lstat(src, (err, stats) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve(stats);
+            });
+        });
+    }
+    chmod(src, mode, { sync = false } = {}) {
+        src = this.resolve(src);
+        if (sync) {
+            return recurseIoSync.default.chmod(src, mode);
+        }
+        return new Promise((resolve, reject) => {
+            recurseIo.default.chmod(src, mode, (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+    chown(src, uid, gid, { sync = false } = {}) {
+        src = this.resolve(src);
+        if (sync) {
+            return recurseIoSync.default.chown(src, uid, gid);
+        }
+        return new Promise((resolve, reject) => {
+            recurseIo.default.chown(src, uid, gid, (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+    symlink(src, use, { sync = false } = {}) {
+        src = this.resolve(src);
+        use = this.resolve(use);
+        if (sync) {
+            return fs.symlinkSync(src, use);
+        }
+        return new Promise((resolve, reject) => {
+            fs.symlink(src, use, (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+    copy(src, dir, { sync = false, umask = 0o000 } = {}) {
+        src = this.resolve(src);
+        dir = this.resolve(dir);
+        if (sync) {
+            return recurseIoSync.default.copy(src, dir, umask);
+        }
+        return new Promise((resolve, reject) => {
+            recurseIo.default.copy(src, dir, umask, (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+    rename(src, use, { sync = false } = {}) {
+        src = this.resolve(src);
+        use = this.resolve(use);
+        if (sync) {
+            return fs.renameSync(src, use);
+        }
+        return new Promise((resolve, reject) => {
+            fs.rename(src, use, (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+    remove(src, { sync = false } = {}) {
+        src = this.resolve(src);
+        if (sync) {
+            return recurseIoSync.default.remove(src);
+        }
+        return new Promise((resolve, reject) => {
+            recurseIo.default.remove(src, (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+    read(src, { sync = false, encoding = 'utf8', flag = 'r' } = {}) {
+        src = this.resolve(src);
+        if (sync) {
+            return fs.readFileSync(src, {
+                encoding,
+                flag
+            });
+        }
+        return new Promise((resolve, reject) => {
+            fs.readFile(src, {
+                encoding,
+                flag
+            }, (err, raw) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve(raw);
+            });
+        });
+    }
+    write(src, data, { sync = false, encoding = 'utf8', umask = 0o000, flag = 'w' } = {}) {
+        src = this.resolve(src);
+        const mode = 0o666 - umask;
+        if (sync) {
+            return fs.writeFileSync(src, data, {
+                encoding,
+                mode,
+                flag
+            });
+        }
+        return new Promise((resolve, reject) => {
+            fs.writeFile(src, data, {
+                encoding,
+                mode,
+                flag
+            }, (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+    append(src, data, { sync = false, encoding = 'utf8', umask = 0o000, flag = 'a' } = {}) {
+        src = this.resolve(src);
+        const mode = 0o666 - umask;
+        if (sync) {
+            return fs.appendFileSync(src, data, {
+                encoding,
+                mode,
+                flag
+            });
+        }
+        return new Promise((resolve, reject) => {
+            fs.appendFile(src, data, {
+                encoding,
+                mode,
+                flag
+            }, (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+    readdir(dir, { sync = false, encoding = 'utf8' } = {}) {
+        dir = this.resolve(dir);
+        if (sync) {
+            return fs.readdirSync(dir, {
+                encoding
+            });
+        }
+        return new Promise((resolve, reject) => {
+            fs.readdir(dir, { encoding }, (err, list) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve(list);
+            });
+        });
+    }
+    mkdir(dir, { umask = 0o000, sync = false } = {}) {
+        dir = this.resolve(dir);
+        if (sync) {
+            return recurseIoSync.default.mkdir(dir, umask);
+        }
+        return new Promise((resolve, reject) => {
+            recurseIo.default.mkdir(dir, umask, (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+}
+
+exports.PoweredFileSystem = PoweredFileSystem;

package/lib/recurse-io-sync.js

@@ -0,0 +1,90 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('node:fs');
+var path = require('node:path');
+
+const { sep } = path;
+function chmod(src, mode) {
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+        const list = fs.readdirSync(src);
+        for (const loc of list) {
+            chmod(`${src}${sep}${loc}`, mode);
+        }
+    }
+    fs.chmodSync(src, mode);
+}
+function chown(src, uid, gid) {
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+        const list = fs.readdirSync(src);
+        for (const loc of list) {
+            chown(`${src}${sep}${loc}`, uid, gid);
+        }
+    }
+    fs.chownSync(src, uid, gid);
+}
+function copy(src, dir, umask) {
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+        const list = fs.readdirSync(src);
+        const paths = src.split(sep);
+        const loc = paths[paths.length - 1];
+        const mode = 0o777 - umask;
+        dir = `${dir}${sep}${loc}`;
+        fs.mkdirSync(dir, mode);
+        for (const loc of list) {
+            copy(`${src}${sep}${loc}`, dir, umask);
+        }
+    }
+    else {
+        const loc = path.basename(src);
+        const use = `${dir}${sep}${loc}`;
+        fs.copyFileSync(src, use);
+    }
+}
+function remove(src) {
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+        const list = fs.readdirSync(src);
+        for (const loc of list) {
+            remove(`${src}${sep}${loc}`);
+        }
+        fs.rmdirSync(src);
+    }
+    else {
+        fs.unlinkSync(src);
+    }
+}
+function mkdir(dir, umask) {
+    const mode = 0o777 - umask;
+    const cwd = process.cwd();
+    let use = '';
+    if (dir.indexOf(cwd) === 0) {
+        use = cwd;
+        dir = dir.substr(cwd.length);
+    }
+    const ways = dir.split(sep).slice(1);
+    for (const loc of ways) {
+        use += `${sep}${loc}`;
+        try {
+            fs.mkdirSync(use, { mode });
+        }
+        catch (err) {
+            if (err.errno !== -17) {
+                throw err;
+            }
+        }
+    }
+}
+var recurseSync = {
+    chmod,
+    chown,
+    copy,
+    remove,
+    mkdir
+};
+
+exports.default = recurseSync;

package/lib/recurse-io.js

@@ -0,0 +1,194 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('node:fs');
+var path = require('node:path');
+
+const { sep } = path;
+function chmod(src, mode, callback) {
+    let reduce = 0;
+    fs.stat(src, (err, stat) => {
+        if (err) {
+            return callback(err);
+        }
+        if (stat.isDirectory()) {
+            fs.readdir(src, (err, list) => {
+                if (err) {
+                    return callback(err);
+                }
+                if (list.length === 0) {
+                    return fs.chmod(src, mode, callback);
+                }
+                reduce += list.length;
+                for (const loc of list) {
+                    chmod(`${src}${sep}${loc}`, mode, (err) => {
+                        if (err) {
+                            return callback(err);
+                        }
+                        if (--reduce === 0) {
+                            fs.chmod(src, mode, callback);
+                        }
+                    });
+                }
+            });
+        }
+        else {
+            fs.chmod(src, mode, callback);
+        }
+    });
+}
+function chown(src, uid, gid, callback) {
+    let reduce = 0;
+    fs.stat(src, (err, stats) => {
+        if (err) {
+            return callback(err);
+        }
+        if (stats.isDirectory()) {
+            fs.readdir(src, (err, list) => {
+                if (err) {
+                    return callback(err);
+                }
+                if (list.length === 0) {
+                    return fs.chown(src, uid, gid, callback);
+                }
+                reduce += list.length;
+                for (const loc of list) {
+                    chown(`${src}${sep}${loc}`, uid, gid, (err) => {
+                        if (err) {
+                            return callback(err);
+                        }
+                        if (--reduce === 0) {
+                            fs.chown(src, uid, gid, callback);
+                        }
+                    });
+                }
+            });
+        }
+        else {
+            fs.chown(src, uid, gid, callback);
+        }
+    });
+}
+function copy(src, dir, umask, callback) {
+    let reduce = 0;
+    fs.stat(src, (err, stat) => {
+        if (err) {
+            return callback(err);
+        }
+        if (stat.isDirectory()) {
+            fs.readdir(src, (err, list) => {
+                if (err) {
+                    return callback(err);
+                }
+                reduce += list.length;
+                const paths = src.split(sep);
+                const loc = paths[paths.length - 1];
+                const mode = 0o777 - umask;
+                dir = `${dir}${sep}${loc}`;
+                fs.mkdir(dir, { mode }, (err) => {
+                    if (err) {
+                        return callback(err);
+                    }
+                    if (reduce === 0) {
+                        return callback(null);
+                    }
+                    for (const loc of list) {
+                        copy(`${src}${sep}${loc}`, dir, umask, (err) => {
+                            if (err) {
+                                return callback(err);
+                            }
+                            if (--reduce === 0) {
+                                callback(null);
+                            }
+                        });
+                    }
+                });
+            });
+        }
+        else {
+            const mode = 0o666 - umask;
+            const loc = path.basename(src);
+            const readStream = fs.createReadStream(src);
+            const writeStream = fs.createWriteStream(`${dir}${sep}${loc}`, {
+                mode
+            });
+            readStream.on('error', callback);
+            writeStream.on('error', callback);
+            writeStream.on('close', () => {
+                callback(null);
+            });
+            readStream.pipe(writeStream);
+        }
+    });
+}
+function remove(src, callback) {
+    fs.stat(src, (err, stat) => {
+        if (err) {
+            return callback(err);
+        }
+        if (stat.isDirectory()) {
+            fs.readdir(src, (err, list) => {
+                if (err) {
+                    return callback(err);
+                }
+                let reduce = list.length;
+                if (reduce === 0) {
+                    return fs.rmdir(src, callback);
+                }
+                for (const loc of list) {
+                    remove(`${src}${sep}${loc}`, (err) => {
+                        if (err) {
+                            return callback(err);
+                        }
+                        if (--reduce === 0) {
+                            fs.rmdir(src, callback);
+                        }
+                    });
+                }
+            });
+        }
+        else {
+            fs.unlink(src, callback);
+        }
+    });
+}
+function mkdir(dir, umask, callback) {
+    const cwd = process.cwd();
+    if (dir === cwd) {
+        return callback(null);
+    }
+    const sequence = function* (dir, files, mode) {
+        const iter = yield;
+        for (const item of files) {
+            dir += `${sep}${item}`;
+            fs.mkdir(dir, { mode }, (err) => {
+                if (err && err.errno !== -17) {
+                    return callback(err);
+                }
+                iter.next();
+            });
+            yield;
+        }
+        callback(null);
+    };
+    let use = '';
+    if (dir.indexOf(cwd) === 0) {
+        use = cwd;
+        dir = dir.substr(cwd.length);
+    }
+    const files = dir.split(sep);
+    const mode = 0o777 - umask;
+    const iter = sequence(use, files, mode);
+    iter.next();
+    iter.next(iter);
+}
+var recurse = {
+    chmod,
+    chown,
+    copy,
+    remove,
+    mkdir
+};
+
+exports.default = recurse;