pwd-fs 2.4.2 → 3.1.4

package/lib/src/powered-file-system.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoweredFileSystem = exports.bitmask = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const recurse_io_1 = __importDefault(require("./recurse-io"));
+const recurse_io_sync_1 = __importDefault(require("./recurse-io-sync"));
+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
+];
+function 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;
+}
+exports.bitmask = bitmask;
+class PoweredFileSystem {
+    pwd;
+    constants = {
+        e: node_fs_1.default.constants.F_OK,
+        r: node_fs_1.default.constants.R_OK,
+        w: node_fs_1.default.constants.W_OK,
+        x: node_fs_1.default.constants.X_OK
+    };
+    static bitmask = bitmask;
+    constructor(pwd) {
+        this.pwd = pwd ? node_path_1.default.resolve(pwd) : process.cwd();
+    }
+    resolve(src) {
+        return node_path_1.default.resolve(this.pwd, src);
+    }
+    test(src, { sync = false, flag = 'e' } = {}) {
+        const mode = this.constants[flag];
+        src = node_path_1.default.resolve(this.pwd, src);
+        if (sync) {
+            return node_fs_1.default.existsSync(src);
+        }
+        return new Promise((resolve) => {
+            node_fs_1.default.access(src, mode, (err) => {
+                if (err) {
+                    return resolve(false);
+                }
+                resolve(true);
+            });
+        });
+    }
+    stat(src, { sync = false } = {}) {
+        src = this.resolve(src);
+        if (sync) {
+            return node_fs_1.default.lstatSync(src);
+        }
+        return new Promise((resolve, reject) => {
+            node_fs_1.default.lstat(src, (err, stats) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve(stats);
+            });
+        });
+    }
+    chmod(src, mode, { sync = false } = {}) {
+        src = this.resolve(src);
+        if (sync) {
+            return recurse_io_sync_1.default.chmod(src, mode);
+        }
+        return new Promise((resolve, reject) => {
+            recurse_io_1.default.chmod(src, mode, (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+    chown(src, uid, gid, { sync = false } = {}) {
+        src = this.resolve(src);
+        if (sync) {
+            return recurse_io_sync_1.default.chown(src, uid, gid);
+        }
+        return new Promise((resolve, reject) => {
+            recurse_io_1.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 node_fs_1.default.symlinkSync(src, use);
+        }
+        return new Promise((resolve, reject) => {
+            node_fs_1.default.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 recurse_io_sync_1.default.copy(src, dir, umask);
+        }
+        return new Promise((resolve, reject) => {
+            recurse_io_1.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 node_fs_1.default.renameSync(src, use);
+        }
+        return new Promise((resolve, reject) => {
+            node_fs_1.default.rename(src, use, (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+    remove(src, { sync = false } = {}) {
+        src = this.resolve(src);
+        if (sync) {
+            return recurse_io_sync_1.default.remove(src);
+        }
+        return new Promise((resolve, reject) => {
+            recurse_io_1.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 node_fs_1.default.readFileSync(src, {
+                encoding,
+                flag
+            });
+        }
+        return new Promise((resolve, reject) => {
+            node_fs_1.default.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 node_fs_1.default.writeFileSync(src, data, {
+                encoding,
+                mode,
+                flag
+            });
+        }
+        return new Promise((resolve, reject) => {
+            node_fs_1.default.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 node_fs_1.default.appendFileSync(src, data, {
+                encoding,
+                mode,
+                flag
+            });
+        }
+        return new Promise((resolve, reject) => {
+            node_fs_1.default.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 node_fs_1.default.readdirSync(dir, {
+                encoding
+            });
+        }
+        return new Promise((resolve, reject) => {
+            node_fs_1.default.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 recurse_io_sync_1.default.mkdir(dir, umask);
+        }
+        return new Promise((resolve, reject) => {
+            recurse_io_1.default.mkdir(dir, umask, (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+}
+exports.PoweredFileSystem = PoweredFileSystem;

package/lib/src/recurse-io-sync.d.ts

@@ -1,8 +1,13 @@
+declare function chmod(src: string, mode: number): void;
+declare function chown(src: string, uid: number, gid: number): void;
+declare function copy(src: string, dir: string, umask: number): void;
+declare function remove(src: string): void;
+declare function mkdir(dir: string, umask: number): void;
 declare const _default: {
-    chmod(src: string, mode: number): void;
-    chown(src: string, uid: number, gid: number): void;
-    copy(src: string, dir: string, umask: number): void;
-    remove(src: string): void;
-    mkdir(dir: string, umask: number): void;
+    chmod: typeof chmod;
+    chown: typeof chown;
+    copy: typeof copy;
+    remove: typeof remove;
+    mkdir: typeof mkdir;
 };
 export default _default;

package/lib/src/recurse-io-sync.js

@@ -3,81 +3,86 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const { sep } = path_1.default;
-exports.default = {
-    chmod(src, mode) {
-        const stat = fs_1.default.statSync(src);
-        if (stat.isDirectory()) {
-            const list = fs_1.default.readdirSync(src);
-            for (const loc of list) {
-                this.chmod(`${src}${sep}${loc}`, mode);
-            }
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const { sep } = node_path_1.default;
+function chmod(src, mode) {
+    const stat = node_fs_1.default.statSync(src);
+    if (stat.isDirectory()) {
+        const list = node_fs_1.default.readdirSync(src);
+        for (const loc of list) {
+            chmod(`${src}${sep}${loc}`, mode);
         }
-        fs_1.default.chmodSync(src, mode);
-    },
-    chown(src, uid, gid) {
-        const stat = fs_1.default.statSync(src);
-        if (stat.isDirectory()) {
-            const list = fs_1.default.readdirSync(src);
-            for (const loc of list) {
-                this.chown(`${src}${sep}${loc}`, uid, gid);
-            }
-        }
-        fs_1.default.chownSync(src, uid, gid);
-    },
-    copy(src, dir, umask) {
-        const stat = fs_1.default.statSync(src);
-        if (stat.isDirectory()) {
-            const list = fs_1.default.readdirSync(src);
-            const paths = src.split(sep);
-            const loc = paths[paths.length - 1];
-            const mode = 0o777 - umask;
-            dir = `${dir}${sep}${loc}`;
-            fs_1.default.mkdirSync(dir, mode);
-            for (const loc of list) {
-                this.copy(`${src}${sep}${loc}`, dir, umask);
-            }
-        }
-        else {
-            const loc = path_1.default.basename(src);
-            const use = `${dir}${sep}${loc}`;
-            fs_1.default.copyFileSync(src, use);
+    }
+    node_fs_1.default.chmodSync(src, mode);
+}
+function chown(src, uid, gid) {
+    const stat = node_fs_1.default.statSync(src);
+    if (stat.isDirectory()) {
+        const list = node_fs_1.default.readdirSync(src);
+        for (const loc of list) {
+            chown(`${src}${sep}${loc}`, uid, gid);
         }
-    },
-    remove(src) {
-        const stat = fs_1.default.statSync(src);
-        if (stat.isDirectory()) {
-            const list = fs_1.default.readdirSync(src);
-            for (const loc of list) {
-                this.remove(`${src}${sep}${loc}`);
-            }
-            fs_1.default.rmdirSync(src);
+    }
+    node_fs_1.default.chownSync(src, uid, gid);
+}
+function copy(src, dir, umask) {
+    const stat = node_fs_1.default.statSync(src);
+    if (stat.isDirectory()) {
+        const list = node_fs_1.default.readdirSync(src);
+        const paths = src.split(sep);
+        const loc = paths[paths.length - 1];
+        const mode = 0o777 - umask;
+        dir = `${dir}${sep}${loc}`;
+        node_fs_1.default.mkdirSync(dir, mode);
+        for (const loc of list) {
+            copy(`${src}${sep}${loc}`, dir, umask);
         }
-        else {
-            fs_1.default.unlinkSync(src);
+    }
+    else {
+        const loc = node_path_1.default.basename(src);
+        const use = `${dir}${sep}${loc}`;
+        node_fs_1.default.copyFileSync(src, use);
+    }
+}
+function remove(src) {
+    const stat = node_fs_1.default.statSync(src);
+    if (stat.isDirectory()) {
+        const list = node_fs_1.default.readdirSync(src);
+        for (const loc of list) {
+            remove(`${src}${sep}${loc}`);
         }
-    },
-    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);
+        node_fs_1.default.rmdirSync(src);
+    }
+    else {
+        node_fs_1.default.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 {
+            node_fs_1.default.mkdirSync(use, { mode });
         }
-        const ways = dir.split(sep).slice(1);
-        for (const loc of ways) {
-            use += `${sep}${loc}`;
-            try {
-                fs_1.default.mkdirSync(use, { mode });
-            }
-            catch (err) {
-                if (err.errno !== -17) {
-                    throw err;
-                }
+        catch (err) {
+            if (err.errno !== -17) {
+                throw err;
             }
         }
     }
+}
+exports.default = {
+    chmod,
+    chown,
+    copy,
+    remove,
+    mkdir
 };

package/lib/src/recurse-io.d.ts

@@ -1,9 +1,17 @@
-import fs from 'fs';
+/// <reference types="node" />
+import fs from 'node:fs';
+export type Files = Array<string>;
+export type NoParamCallback = fs.NoParamCallback;
+declare function chmod(src: string, mode: number, callback: NoParamCallback): void;
+declare function chown(src: string, uid: number, gid: number, callback: NoParamCallback): void;
+declare function copy(src: string, dir: string, umask: number, callback: NoParamCallback): void;
+declare function remove(src: string, callback: NoParamCallback): void;
+declare function mkdir(dir: string, umask: number, callback: NoParamCallback): void;
 declare const _default: {
-    chmod(src: string, mode: number, callback: fs.NoParamCallback): void;
-    chown(src: string, uid: number, gid: number, callback: fs.NoParamCallback): void;
-    copy(src: string, dir: string, umask: number, callback: fs.NoParamCallback): void;
-    remove(src: string, callback: fs.NoParamCallback): void;
-    mkdir(dir: string, umask: number, callback: fs.NoParamCallback): void;
+    chmod: typeof chmod;
+    chown: typeof chown;
+    copy: typeof copy;
+    remove: typeof remove;
+    mkdir: typeof mkdir;
 };
 export default _default;