pwd-fs 3.1.3 → 3.1.4

package/lib/src/index.d.ts

@@ -1,6 +1,4 @@
-import { type Mode as TMode, type Flag as TFlag, type Stats as TStats, PoweredFileSystem } from './powered-file-system';
-export type Mode = TMode;
-export type Flag = TFlag;
-export type Stats = TStats;
-export declare const bitmask: typeof PoweredFileSystem.bitmask;
+import { PoweredFileSystem } from './powered-file-system';
+export declare const pfs: PoweredFileSystem;
 export default PoweredFileSystem;
+export * from './powered-file-system';

package/lib/src/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pfs = void 0;
+const powered_file_system_1 = require("./powered-file-system");
+exports.pfs = new powered_file_system_1.PoweredFileSystem();
+exports.default = powered_file_system_1.PoweredFileSystem;
+__exportStar(require("./powered-file-system"), exports);

package/lib/src/powered-file-system.d.ts

@@ -10,12 +10,13 @@ export interface IConstants {
     w: number;
     x: number;
 }
+export declare function bitmask(mode: number): number;
 export declare class PoweredFileSystem {
     readonly pwd: string;
     readonly constants: IConstants;
+    static bitmask: typeof bitmask;
     constructor(pwd?: string);
     private resolve;
-    static bitmask(mode: number): number;
     test(src: string, options: {
         sync: true;
         flag?: Mode;

package/lib/{powered-file-system.js → src/powered-file-system.js}

@@ -1,10 +1,13 @@
-'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');
-
+"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
@@ -16,41 +19,43 @@ const permissions = [
     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: fs.constants.F_OK,
-        r: fs.constants.R_OK,
-        w: fs.constants.W_OK,
-        x: fs.constants.X_OK
+        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 ? path.resolve(pwd) : process.cwd();
+        this.pwd = pwd ? node_path_1.default.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;
+        return node_path_1.default.resolve(this.pwd, src);
     }
     test(src, { sync = false, flag = 'e' } = {}) {
         const mode = this.constants[flag];
-        src = path.resolve(this.pwd, src);
+        src = node_path_1.default.resolve(this.pwd, src);
         if (sync) {
-            return fs.existsSync(src);
+            return node_fs_1.default.existsSync(src);
         }
         return new Promise((resolve) => {
-            fs.access(src, mode, (err) => {
+            node_fs_1.default.access(src, mode, (err) => {
                 if (err) {
                     return resolve(false);
                 }
@@ -61,10 +66,10 @@ class PoweredFileSystem {
     stat(src, { sync = false } = {}) {
         src = this.resolve(src);
         if (sync) {
-            return fs.lstatSync(src);
+            return node_fs_1.default.lstatSync(src);
         }
         return new Promise((resolve, reject) => {
-            fs.lstat(src, (err, stats) => {
+            node_fs_1.default.lstat(src, (err, stats) => {
                 if (err) {
                     return reject(err);
                 }
@@ -75,10 +80,10 @@ class PoweredFileSystem {
     chmod(src, mode, { sync = false } = {}) {
         src = this.resolve(src);
         if (sync) {
-            return recurseIoSync.default.chmod(src, mode);
+            return recurse_io_sync_1.default.chmod(src, mode);
         }
         return new Promise((resolve, reject) => {
-            recurseIo.default.chmod(src, mode, (err) => {
+            recurse_io_1.default.chmod(src, mode, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -89,10 +94,10 @@ class PoweredFileSystem {
     chown(src, uid, gid, { sync = false } = {}) {
         src = this.resolve(src);
         if (sync) {
-            return recurseIoSync.default.chown(src, uid, gid);
+            return recurse_io_sync_1.default.chown(src, uid, gid);
         }
         return new Promise((resolve, reject) => {
-            recurseIo.default.chown(src, uid, gid, (err) => {
+            recurse_io_1.default.chown(src, uid, gid, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -104,10 +109,10 @@ class PoweredFileSystem {
         src = this.resolve(src);
         use = this.resolve(use);
         if (sync) {
-            return fs.symlinkSync(src, use);
+            return node_fs_1.default.symlinkSync(src, use);
         }
         return new Promise((resolve, reject) => {
-            fs.symlink(src, use, (err) => {
+            node_fs_1.default.symlink(src, use, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -119,10 +124,10 @@ class PoweredFileSystem {
         src = this.resolve(src);
         dir = this.resolve(dir);
         if (sync) {
-            return recurseIoSync.default.copy(src, dir, umask);
+            return recurse_io_sync_1.default.copy(src, dir, umask);
         }
         return new Promise((resolve, reject) => {
-            recurseIo.default.copy(src, dir, umask, (err) => {
+            recurse_io_1.default.copy(src, dir, umask, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -134,10 +139,10 @@ class PoweredFileSystem {
         src = this.resolve(src);
         use = this.resolve(use);
         if (sync) {
-            return fs.renameSync(src, use);
+            return node_fs_1.default.renameSync(src, use);
         }
         return new Promise((resolve, reject) => {
-            fs.rename(src, use, (err) => {
+            node_fs_1.default.rename(src, use, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -148,10 +153,10 @@ class PoweredFileSystem {
     remove(src, { sync = false } = {}) {
         src = this.resolve(src);
         if (sync) {
-            return recurseIoSync.default.remove(src);
+            return recurse_io_sync_1.default.remove(src);
         }
         return new Promise((resolve, reject) => {
-            recurseIo.default.remove(src, (err) => {
+            recurse_io_1.default.remove(src, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -162,13 +167,13 @@ class PoweredFileSystem {
     read(src, { sync = false, encoding = 'utf8', flag = 'r' } = {}) {
         src = this.resolve(src);
         if (sync) {
-            return fs.readFileSync(src, {
+            return node_fs_1.default.readFileSync(src, {
                 encoding,
                 flag
             });
         }
         return new Promise((resolve, reject) => {
-            fs.readFile(src, {
+            node_fs_1.default.readFile(src, {
                 encoding,
                 flag
             }, (err, raw) => {
@@ -183,14 +188,14 @@ class PoweredFileSystem {
         src = this.resolve(src);
         const mode = 0o666 - umask;
         if (sync) {
-            return fs.writeFileSync(src, data, {
+            return node_fs_1.default.writeFileSync(src, data, {
                 encoding,
                 mode,
                 flag
             });
         }
         return new Promise((resolve, reject) => {
-            fs.writeFile(src, data, {
+            node_fs_1.default.writeFile(src, data, {
                 encoding,
                 mode,
                 flag
@@ -206,14 +211,14 @@ class PoweredFileSystem {
         src = this.resolve(src);
         const mode = 0o666 - umask;
         if (sync) {
-            return fs.appendFileSync(src, data, {
+            return node_fs_1.default.appendFileSync(src, data, {
                 encoding,
                 mode,
                 flag
             });
         }
         return new Promise((resolve, reject) => {
-            fs.appendFile(src, data, {
+            node_fs_1.default.appendFile(src, data, {
                 encoding,
                 mode,
                 flag
@@ -228,12 +233,12 @@ class PoweredFileSystem {
     readdir(dir, { sync = false, encoding = 'utf8' } = {}) {
         dir = this.resolve(dir);
         if (sync) {
-            return fs.readdirSync(dir, {
+            return node_fs_1.default.readdirSync(dir, {
                 encoding
             });
         }
         return new Promise((resolve, reject) => {
-            fs.readdir(dir, { encoding }, (err, list) => {
+            node_fs_1.default.readdir(dir, { encoding }, (err, list) => {
                 if (err) {
                     return reject(err);
                 }
@@ -244,10 +249,10 @@ class PoweredFileSystem {
     mkdir(dir, { umask = 0o000, sync = false } = {}) {
         dir = this.resolve(dir);
         if (sync) {
-            return recurseIoSync.default.mkdir(dir, umask);
+            return recurse_io_sync_1.default.mkdir(dir, umask);
         }
         return new Promise((resolve, reject) => {
-            recurseIo.default.mkdir(dir, umask, (err) => {
+            recurse_io_1.default.mkdir(dir, umask, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -256,5 +261,4 @@ class PoweredFileSystem {
         });
     }
 }
-
 exports.PoweredFileSystem = PoweredFileSystem;

package/lib/{recurse-io-sync.js → src/recurse-io-sync.js}

@@ -1,61 +1,61 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var fs = require('node:fs');
-var path = require('node:path');
-
-const { sep } = path;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = fs.statSync(src);
+    const stat = node_fs_1.default.statSync(src);
     if (stat.isDirectory()) {
-        const list = fs.readdirSync(src);
+        const list = node_fs_1.default.readdirSync(src);
         for (const loc of list) {
             chmod(`${src}${sep}${loc}`, mode);
         }
     }
-    fs.chmodSync(src, mode);
+    node_fs_1.default.chmodSync(src, mode);
 }
 function chown(src, uid, gid) {
-    const stat = fs.statSync(src);
+    const stat = node_fs_1.default.statSync(src);
     if (stat.isDirectory()) {
-        const list = fs.readdirSync(src);
+        const list = node_fs_1.default.readdirSync(src);
         for (const loc of list) {
             chown(`${src}${sep}${loc}`, uid, gid);
         }
     }
-    fs.chownSync(src, uid, gid);
+    node_fs_1.default.chownSync(src, uid, gid);
 }
 function copy(src, dir, umask) {
-    const stat = fs.statSync(src);
+    const stat = node_fs_1.default.statSync(src);
     if (stat.isDirectory()) {
-        const list = fs.readdirSync(src);
+        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}`;
-        fs.mkdirSync(dir, mode);
+        node_fs_1.default.mkdirSync(dir, mode);
         for (const loc of list) {
             copy(`${src}${sep}${loc}`, dir, umask);
         }
     }
     else {
-        const loc = path.basename(src);
+        const loc = node_path_1.default.basename(src);
         const use = `${dir}${sep}${loc}`;
-        fs.copyFileSync(src, use);
+        node_fs_1.default.copyFileSync(src, use);
     }
 }
 function remove(src) {
-    const stat = fs.statSync(src);
+    const stat = node_fs_1.default.statSync(src);
     if (stat.isDirectory()) {
-        const list = fs.readdirSync(src);
+        const list = node_fs_1.default.readdirSync(src);
         for (const loc of list) {
             remove(`${src}${sep}${loc}`);
         }
-        fs.rmdirSync(src);
+        node_fs_1.default.rmdirSync(src);
     }
     else {
-        fs.unlinkSync(src);
+        node_fs_1.default.unlinkSync(src);
     }
 }
 function mkdir(dir, umask) {
@@ -70,7 +70,7 @@ function mkdir(dir, umask) {
     for (const loc of ways) {
         use += `${sep}${loc}`;
         try {
-            fs.mkdirSync(use, { mode });
+            node_fs_1.default.mkdirSync(use, { mode });
         }
         catch (err) {
             if (err.errno !== -17) {
@@ -79,12 +79,10 @@ function mkdir(dir, umask) {
         }
     }
 }
-var recurseSync = {
+exports.default = {
     chmod,
     chown,
     copy,
     remove,
     mkdir
 };
-
-exports.default = recurseSync;

package/lib/{recurse-io.js → src/recurse-io.js}

@@ -1,24 +1,24 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var fs = require('node:fs');
-var path = require('node:path');
-
-const { sep } = path;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
-    fs.stat(src, (err, stat) => {
+    node_fs_1.default.stat(src, (err, stat) => {
         if (err) {
             return callback(err);
         }
         if (stat.isDirectory()) {
-            fs.readdir(src, (err, list) => {
+            node_fs_1.default.readdir(src, (err, list) => {
                 if (err) {
                     return callback(err);
                 }
                 if (list.length === 0) {
-                    return fs.chmod(src, mode, callback);
+                    return node_fs_1.default.chmod(src, mode, callback);
                 }
                 reduce += list.length;
                 for (const loc of list) {
@@ -27,30 +27,30 @@ function chmod(src, mode, callback) {
                             return callback(err);
                         }
                         if (--reduce === 0) {
-                            fs.chmod(src, mode, callback);
+                            node_fs_1.default.chmod(src, mode, callback);
                         }
                     });
                 }
             });
         }
         else {
-            fs.chmod(src, mode, callback);
+            node_fs_1.default.chmod(src, mode, callback);
         }
     });
 }
 function chown(src, uid, gid, callback) {
     let reduce = 0;
-    fs.stat(src, (err, stats) => {
+    node_fs_1.default.stat(src, (err, stats) => {
         if (err) {
             return callback(err);
         }
         if (stats.isDirectory()) {
-            fs.readdir(src, (err, list) => {
+            node_fs_1.default.readdir(src, (err, list) => {
                 if (err) {
                     return callback(err);
                 }
                 if (list.length === 0) {
-                    return fs.chown(src, uid, gid, callback);
+                    return node_fs_1.default.chown(src, uid, gid, callback);
                 }
                 reduce += list.length;
                 for (const loc of list) {
@@ -59,25 +59,25 @@ function chown(src, uid, gid, callback) {
                             return callback(err);
                         }
                         if (--reduce === 0) {
-                            fs.chown(src, uid, gid, callback);
+                            node_fs_1.default.chown(src, uid, gid, callback);
                         }
                     });
                 }
             });
         }
         else {
-            fs.chown(src, uid, gid, callback);
+            node_fs_1.default.chown(src, uid, gid, callback);
         }
     });
 }
 function copy(src, dir, umask, callback) {
     let reduce = 0;
-    fs.stat(src, (err, stat) => {
+    node_fs_1.default.stat(src, (err, stat) => {
         if (err) {
             return callback(err);
         }
         if (stat.isDirectory()) {
-            fs.readdir(src, (err, list) => {
+            node_fs_1.default.readdir(src, (err, list) => {
                 if (err) {
                     return callback(err);
                 }
@@ -86,7 +86,7 @@ function copy(src, dir, umask, callback) {
                 const loc = paths[paths.length - 1];
                 const mode = 0o777 - umask;
                 dir = `${dir}${sep}${loc}`;
-                fs.mkdir(dir, { mode }, (err) => {
+                node_fs_1.default.mkdir(dir, { mode }, (err) => {
                     if (err) {
                         return callback(err);
                     }
@@ -108,9 +108,9 @@ function copy(src, dir, umask, callback) {
         }
         else {
             const mode = 0o666 - umask;
-            const loc = path.basename(src);
-            const readStream = fs.createReadStream(src);
-            const writeStream = fs.createWriteStream(`${dir}${sep}${loc}`, {
+            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);
@@ -123,18 +123,18 @@ function copy(src, dir, umask, callback) {
     });
 }
 function remove(src, callback) {
-    fs.stat(src, (err, stat) => {
+    node_fs_1.default.stat(src, (err, stat) => {
         if (err) {
             return callback(err);
         }
         if (stat.isDirectory()) {
-            fs.readdir(src, (err, list) => {
+            node_fs_1.default.readdir(src, (err, list) => {
                 if (err) {
                     return callback(err);
                 }
                 let reduce = list.length;
                 if (reduce === 0) {
-                    return fs.rmdir(src, callback);
+                    return node_fs_1.default.rmdir(src, callback);
                 }
                 for (const loc of list) {
                     remove(`${src}${sep}${loc}`, (err) => {
@@ -142,14 +142,14 @@ function remove(src, callback) {
                             return callback(err);
                         }
                         if (--reduce === 0) {
-                            fs.rmdir(src, callback);
+                            node_fs_1.default.rmdir(src, callback);
                         }
                     });
                 }
             });
         }
         else {
-            fs.unlink(src, callback);
+            node_fs_1.default.unlink(src, callback);
         }
     });
 }
@@ -162,7 +162,7 @@ function mkdir(dir, umask, callback) {
         const iter = yield;
         for (const item of files) {
             dir += `${sep}${item}`;
-            fs.mkdir(dir, { mode }, (err) => {
+            node_fs_1.default.mkdir(dir, { mode }, (err) => {
                 if (err && err.errno !== -17) {
                     return callback(err);
                 }
@@ -183,12 +183,10 @@ function mkdir(dir, umask, callback) {
     iter.next();
     iter.next(iter);
 }
-var recurse = {
+exports.default = {
     chmod,
     chown,
     copy,
     remove,
     mkdir
 };
-
-exports.default = recurse;

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;