pwd-fs 2.4.2 → 3.1.4

package/lib/src/recurse-io.js

@@ -3,186 +3,190 @@ 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, callback) {
-        let reduce = 0;
-        fs_1.default.stat(src, (err, stat) => {
-            if (err) {
-                return callback(err);
-            }
-            if (stat.isDirectory()) {
-                fs_1.default.readdir(src, (err, list) => {
-                    if (err) {
-                        return callback(err);
-                    }
-                    if (list.length === 0) {
-                        return fs_1.default.chmod(src, mode, callback);
-                    }
-                    reduce += list.length;
-                    for (const loc of list) {
-                        this.chmod(`${src}${sep}${loc}`, mode, (err) => {
-                            if (err) {
-                                return callback(err);
-                            }
-                            if (--reduce === 0) {
-                                fs_1.default.chmod(src, mode, callback);
-                            }
-                        });
-                    }
-                });
-            }
-            else {
-                fs_1.default.chmod(src, mode, callback);
-            }
-        });
-    },
-    chown(src, uid, gid, callback) {
-        let reduce = 0;
-        fs_1.default.stat(src, (err, stats) => {
-            if (err) {
-                return callback(err);
-            }
-            if (stats.isDirectory()) {
-                fs_1.default.readdir(src, (err, list) => {
-                    if (err) {
-                        return callback(err);
-                    }
-                    if (list.length === 0) {
-                        return fs_1.default.chown(src, uid, gid, callback);
-                    }
-                    reduce += list.length;
-                    for (const loc of list) {
-                        this.chown(`${src}${sep}${loc}`, uid, gid, (err) => {
-                            if (err) {
-                                return callback(err);
-                            }
-                            if (--reduce === 0) {
-                                fs_1.default.chown(src, uid, gid, callback);
-                            }
-                        });
-                    }
-                });
-            }
-            else {
-                fs_1.default.chown(src, uid, gid, callback);
-            }
-        });
-    },
-    copy(src, dir, umask, callback) {
-        let reduce = 0;
-        fs_1.default.stat(src, (err, stat) => {
-            if (err) {
-                return callback(err);
-            }
-            if (stat.isDirectory()) {
-                fs_1.default.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_1.default.mkdir(dir, { mode }, (err) => {
+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, callback) {
+    let reduce = 0;
+    node_fs_1.default.stat(src, (err, stat) => {
+        if (err) {
+            return callback(err);
+        }
+        if (stat.isDirectory()) {
+            node_fs_1.default.readdir(src, (err, list) => {
+                if (err) {
+                    return callback(err);
+                }
+                if (list.length === 0) {
+                    return node_fs_1.default.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) {
-                            return callback(null);
+                        if (--reduce === 0) {
+                            node_fs_1.default.chmod(src, mode, callback);
                         }
-                        for (const loc of list) {
-                            this.copy(`${src}${sep}${loc}`, dir, umask, (err) => {
-                                if (err) {
-                                    return callback(err);
-                                }
-                                if (--reduce === 0) {
-                                    callback(null);
-                                }
-                            });
+                    });
+                }
+            });
+        }
+        else {
+            node_fs_1.default.chmod(src, mode, callback);
+        }
+    });
+}
+function chown(src, uid, gid, callback) {
+    let reduce = 0;
+    node_fs_1.default.stat(src, (err, stats) => {
+        if (err) {
+            return callback(err);
+        }
+        if (stats.isDirectory()) {
+            node_fs_1.default.readdir(src, (err, list) => {
+                if (err) {
+                    return callback(err);
+                }
+                if (list.length === 0) {
+                    return node_fs_1.default.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) {
+                            node_fs_1.default.chown(src, uid, gid, callback);
                         }
                     });
-                });
-            }
-            else {
-                const mode = 0o666 - umask;
-                const loc = path_1.default.basename(src);
-                const readStream = fs_1.default.createReadStream(src);
-                const writeStream = fs_1.default.createWriteStream(`${dir}${sep}${loc}`, {
-                    mode
-                });
-                readStream.on('error', callback);
-                writeStream.on('error', callback);
-                writeStream.on('close', () => {
-                    callback(null);
-                });
-                readStream.pipe(writeStream);
-            }
-        });
-    },
-    remove(src, callback) {
-        let reduce = 0;
-        fs_1.default.stat(src, (err, stat) => {
-            if (err) {
-                return callback(err);
-            }
-            if (stat.isDirectory()) {
-                fs_1.default.readdir(src, (err, list) => {
+                }
+            });
+        }
+        else {
+            node_fs_1.default.chown(src, uid, gid, callback);
+        }
+    });
+}
+function copy(src, dir, umask, callback) {
+    let reduce = 0;
+    node_fs_1.default.stat(src, (err, stat) => {
+        if (err) {
+            return callback(err);
+        }
+        if (stat.isDirectory()) {
+            node_fs_1.default.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}`;
+                node_fs_1.default.mkdir(dir, { mode }, (err) => {
                     if (err) {
                         return callback(err);
                     }
-                    if (list.length === 0) {
-                        return fs_1.default.rmdir(src, callback);
+                    if (reduce === 0) {
+                        return callback(null);
                     }
-                    reduce += list.length;
                     for (const loc of list) {
-                        this.remove(`${src}${sep}${loc}`, (err) => {
+                        copy(`${src}${sep}${loc}`, dir, umask, (err) => {
                             if (err) {
                                 return callback(err);
                             }
                             if (--reduce === 0) {
-                                fs_1.default.rmdir(src, callback);
+                                callback(null);
                             }
                         });
                     }
                 });
-            }
-            else {
-                fs_1.default.unlink(src, callback);
-            }
-        });
-    },
-    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_1.default.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);
+        else {
+            const mode = 0o666 - umask;
+            const loc = node_path_1.default.basename(src);
+            const readStream = node_fs_1.default.createReadStream(src);
+            const writeStream = node_fs_1.default.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) {
+    node_fs_1.default.stat(src, (err, stat) => {
+        if (err) {
+            return callback(err);
+        }
+        if (stat.isDirectory()) {
+            node_fs_1.default.readdir(src, (err, list) => {
+                if (err) {
+                    return callback(err);
+                }
+                let reduce = list.length;
+                if (reduce === 0) {
+                    return node_fs_1.default.rmdir(src, callback);
+                }
+                for (const loc of list) {
+                    remove(`${src}${sep}${loc}`, (err) => {
+                        if (err) {
+                            return callback(err);
+                        }
+                        if (--reduce === 0) {
+                            node_fs_1.default.rmdir(src, callback);
+                        }
+                    });
+                }
+            });
+        }
+        else {
+            node_fs_1.default.unlink(src, callback);
         }
-        const files = dir.split(sep);
-        const mode = 0o777 - umask;
-        const iter = sequence(use, files, mode);
-        iter.next();
-        iter.next(iter);
+    });
+}
+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}`;
+            node_fs_1.default.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);
+}
+exports.default = {
+    chmod,
+    chown,
+    copy,
+    remove,
+    mkdir
 };

package/lib/test/__fmock.d.ts

@@ -0,0 +1,5 @@
+export interface Iframe {
+    [key: string]: any;
+}
+export declare function fmock(frame: Iframe): void;
+export declare function restore(tmpDir: string): void;

package/lib/test/__fmock.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restore = exports.fmock = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function fmock(frame) {
+    for (const src of Object.keys(frame)) {
+        const { dir } = node_path_1.default.parse(src);
+        const value = frame[src];
+        node_fs_1.default.mkdirSync(dir, { recursive: true });
+        if (value.type === 'directory') {
+            node_fs_1.default.mkdirSync(src);
+        }
+        if (value.type === 'file') {
+            node_fs_1.default.writeFileSync(src, value.data);
+        }
+        if (value.type === 'symlink') {
+            node_fs_1.default.symlinkSync(value.target, src);
+        }
+    }
+}
+exports.fmock = fmock;
+function restore(tmpDir) {
+    const removeRecursive = (src) => {
+        if (node_fs_1.default.existsSync(src)) {
+            node_fs_1.default.readdirSync(src).forEach((item) => {
+                const curl = `${src}/${item}`;
+                node_fs_1.default.lstatSync(curl).isDirectory()
+                    ? removeRecursive(curl)
+                    : node_fs_1.default.unlinkSync(curl);
+            });
+            node_fs_1.default.rmdirSync(src);
+        }
+    };
+    removeRecursive(tmpDir);
+}
+exports.restore = restore;

package/lib/test/append.spec.js

@@ -3,97 +3,56 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const assert_1 = __importDefault(require("assert"));
-const path_1 = require("path");
-const mock_fs_1 = __importDefault(require("mock-fs"));
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
 const chance_1 = __importDefault(require("chance"));
-const src_1 = __importDefault(require("../src"));
+const expect_1 = require("expect");
+const __fmock_1 = require("./__fmock");
+const src_1 = require("../src");
 describe('append(src, data [, options])', () => {
+    const chance = new chance_1.default();
     beforeEach(() => {
-        const chance = new chance_1.default();
-        (0, mock_fs_1.default)({
-            'tmpdir': {
-                'binapp': chance.string(),
-                'libxbase': mock_fs_1.default.directory()
-            },
-            'flexapp': mock_fs_1.default.symlink({
-                path: 'tmpdir/binapp'
-            })
+        (0, __fmock_1.fmock)({
+            './tmpdir/tings.txt': {
+                type: 'file',
+                data: 'hoodie'
+            }
         });
     });
-    afterEach(mock_fs_1.default.restore);
-    it('Positive: Must append content to file', async () => {
-        const pfs = new src_1.default();
-        const chance = new chance_1.default();
-        const before = await pfs.stat('./tmpdir/binapp');
-        const payload = chance.string();
-        await pfs.append('./tmpdir/binapp', payload);
-        const after = await pfs.stat('./tmpdir/binapp');
-        (0, assert_1.default)(after.size > before.size);
+    afterEach(() => {
+        (0, __fmock_1.restore)('./tmpdir');
     });
-    it('Positive: Must append content to file when path is absolute', async () => {
-        const pfs = new src_1.default();
-        const chance = new chance_1.default();
-        const before = await pfs.stat('./tmpdir/binapp');
-        const cwd = process.cwd();
-        const payload = chance.string();
-        await pfs.append(`${cwd}${path_1.sep}tmpdir${path_1.sep}binapp`, payload, {
-            resolve: false
-        });
-        const after = await pfs.stat('./tmpdir/binapp');
-        (0, assert_1.default)(after.size > before.size);
+    it('Positive: Must append content to file', async () => {
+        const payload = chance.paragraph();
+        await src_1.pfs.append('./tmpdir/tings.txt', payload);
+        const { size } = node_fs_1.default.statSync('./tmpdir/tings.txt');
+        (0, node_assert_1.default)(payload.length + 6 === size);
     });
     it(`Negative: Unexpected option 'flag' returns Error`, async () => {
-        const pfs = new src_1.default();
-        const chance = new chance_1.default();
-        try {
-            const payload = chance.string();
-            await pfs.append('./tmpdir/binapp', payload, {
+        const payload = chance.paragraph();
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.append('./tmpdir/tings.txt', payload, {
                 flag: 'r'
             });
-        }
-        catch (err) {
-            (0, assert_1.default)(err.errno === -9);
-        }
+        })
+            .rejects
+            .toThrow();
     });
-    describe('sync mode', () => {
-        it(`Positive: Must append content to file`, async () => {
-            const pfs = new src_1.default();
-            const chance = new chance_1.default();
-            const before = await pfs.stat('./tmpdir/binapp');
-            const payload = chance.string();
-            pfs.append('./tmpdir/binapp', payload, {
-                sync: true
-            });
-            const after = await pfs.stat('./tmpdir/binapp');
-            (0, assert_1.default)(after.size > before.size);
+    it(`[sync] Positive: Must append content to file`, () => {
+        const payload = chance.paragraph();
+        src_1.pfs.append('./tmpdir/tings.txt', payload, {
+            sync: true
         });
-        it('Positive: Must append content to file when path is absolute', async () => {
-            const pfs = new src_1.default();
-            const chance = new chance_1.default();
-            const before = await pfs.stat('./tmpdir/binapp');
-            const cwd = process.cwd();
-            const payload = chance.string();
-            pfs.append(`${cwd}${path_1.sep}tmpdir${path_1.sep}binapp`, payload, {
+        const { size } = node_fs_1.default.statSync('./tmpdir/tings.txt');
+        (0, node_assert_1.default)(payload.length + 6 === size);
+    });
+    it(`[sync] Negative: Unexpected option 'flag' returns Error`, () => {
+        const payload = chance.paragraph();
+        node_assert_1.default.throws(() => {
+            src_1.pfs.append('./tmpdir/tings.txt', payload, {
                 sync: true,
-                resolve: false
+                flag: 'r'
             });
-            const after = await pfs.stat('./tmpdir/binapp');
-            (0, assert_1.default)(after.size > before.size);
-        });
-        it(`Negative: Unexpected option 'flag' returns Error`, async () => {
-            const pfs = new src_1.default();
-            const chance = new chance_1.default();
-            try {
-                const payload = chance.string();
-                pfs.append('./tmpdir/binapp', payload, {
-                    sync: true,
-                    flag: 'r'
-                });
-            }
-            catch (err) {
-                (0, assert_1.default)(err.errno === -9);
-            }
         });
     });
 });

package/lib/test/bitmask.spec.js

@@ -3,27 +3,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const assert_1 = __importDefault(require("assert"));
-const src_1 = __importDefault(require("../src"));
+const node_assert_1 = __importDefault(require("node:assert"));
+const src_1 = require("../src");
 describe('static bitmask(mode: number)', () => {
     it('Positive: Calculate bitmask', () => {
-        (0, assert_1.default)(src_1.default.bitmask(33024) === 0o400); // (r--------)
-        (0, assert_1.default)(src_1.default.bitmask(33152) === 0o600); // (rw-------)
-        (0, assert_1.default)(src_1.default.bitmask(33216) === 0o700); // (rwx------)
-        (0, assert_1.default)(src_1.default.bitmask(32800) === 0o040); // (---r-----)
-        (0, assert_1.default)(src_1.default.bitmask(32816) === 0o060); // (---rw----)
-        (0, assert_1.default)(src_1.default.bitmask(32824) === 0o070); // (---rwx---)
-        (0, assert_1.default)(src_1.default.bitmask(32772) === 0o004); // (------r--)
-        (0, assert_1.default)(src_1.default.bitmask(32774) === 0o006); // (------rw-)
-        (0, assert_1.default)(src_1.default.bitmask(32775) === 0o007); // (------rwx)
+        (0, node_assert_1.default)((0, src_1.bitmask)(33024) === 0o400); // (r--------)
+        (0, node_assert_1.default)((0, src_1.bitmask)(33152) === 0o600); // (rw-------)
+        (0, node_assert_1.default)((0, src_1.bitmask)(33216) === 0o700); // (rwx------)
+        (0, node_assert_1.default)((0, src_1.bitmask)(32800) === 0o040); // (---r-----)
+        (0, node_assert_1.default)((0, src_1.bitmask)(32816) === 0o060); // (---rw----)
+        (0, node_assert_1.default)((0, src_1.bitmask)(32824) === 0o070); // (---rwx---)
+        (0, node_assert_1.default)((0, src_1.bitmask)(32772) === 0o004); // (------r--)
+        (0, node_assert_1.default)((0, src_1.bitmask)(32774) === 0o006); // (------rw-)
+        (0, node_assert_1.default)((0, src_1.bitmask)(32775) === 0o007); // (------rwx)
     });
     it(`Negative: Throw an exception if the argument is 'null' type`, () => {
-        try {
+        node_assert_1.default.throws(() => {
             // @ts-ignore
-            src_1.default.bitmask(null);
-        }
-        catch (err) {
-            (0, assert_1.default)(err);
-        }
+            (0, src_1.bitmask)(null);
+        });
     });
 });