pwd-fs 3.2.4 → 3.3.2

package/dist/powered-file-system.js

@@ -0,0 +1,144 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoweredFileSystem = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const bitmask_1 = require("./bitmask");
+const append_1 = require("./powered-file-system/append");
+const chmod_1 = require("./powered-file-system/chmod");
+const chown_1 = require("./powered-file-system/chown");
+const copy_1 = require("./powered-file-system/copy");
+const mkdir_1 = require("./powered-file-system/mkdir");
+const read_1 = require("./powered-file-system/read");
+const readdir_1 = require("./powered-file-system/readdir");
+const remove_1 = require("./powered-file-system/remove");
+const rename_1 = require("./powered-file-system/rename");
+const stat_1 = require("./powered-file-system/stat");
+const symlink_1 = require("./powered-file-system/symlink");
+const test_1 = require("./powered-file-system/test");
+const write_1 = require("./powered-file-system/write");
+__exportStar(require("./bitmask"), exports);
+/**
+ * Path-aware wrapper around Node's file system APIs.
+ *
+ * All relative paths are resolved against `pwd`, which makes the instance
+ * suitable for sandboxed or virtual working-directory workflows.
+ */
+class PoweredFileSystem {
+    pwd;
+    /**
+     * Access mode aliases used by `test()`.
+     */
+    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
+    };
+    /**
+     * Exposes permission mask normalization as a static helper.
+     */
+    static bitmask = bitmask_1.bitmask;
+    /**
+     * @param pwd Base directory used to resolve all relative paths.
+     */
+    constructor(pwd) {
+        this.pwd = pwd ? node_path_1.default.resolve(pwd) : process.cwd();
+    }
+    /**
+     * Checks whether the given path is accessible with the requested mode.
+     */
+    test(src, options) {
+        return test_1.test.call(this, src, options);
+    }
+    /**
+     * Returns `lstat` information for a path.
+     */
+    stat(src, options) {
+        return stat_1.stat.call(this, src, options);
+    }
+    /**
+     * Applies a mode recursively to a file or directory tree.
+     */
+    chmod(src, mode, options) {
+        return chmod_1.chmod.call(this, src, mode, options);
+    }
+    /**
+     * Applies ownership recursively to a file or directory tree.
+     */
+    chown(src, options) {
+        return chown_1.chown.call(this, src, options);
+    }
+    /**
+     * Creates a symbolic link from `dest` to `src`.
+     */
+    symlink(src, dest, options) {
+        return symlink_1.symlink.call(this, src, dest, options);
+    }
+    /**
+     * Copies `src` into the destination directory.
+     */
+    copy(src, dest, options) {
+        return copy_1.copy.call(this, src, dest, options);
+    }
+    /**
+     * Renames or moves a file system node.
+     */
+    rename(src, dest, options) {
+        return rename_1.rename.call(this, src, dest, options);
+    }
+    /**
+     * Removes a file system node recursively.
+     */
+    remove(src, options) {
+        return remove_1.remove.call(this, src, options);
+    }
+    /**
+     * Reads a file relative to the current instance root.
+     */
+    read(src, options) {
+        return read_1.read.call(this, src, options);
+    }
+    /**
+     * Writes a file and applies the resulting permissions explicitly.
+     */
+    write(src, data, options) {
+        return write_1.write.call(this, src, data, options);
+    }
+    /**
+     * @deprecated Use `write(..., { flag: 'a' })` instead.
+     */
+    append(src, data, options) {
+        return append_1.append.call(this, src, data, options);
+    }
+    /**
+     * Lists directory entries relative to the current instance root.
+     */
+    readdir(dir, options) {
+        return readdir_1.readdir.call(this, dir, options);
+    }
+    /**
+     * Creates a directory tree relative to the current instance root.
+     */
+    mkdir(dir, options) {
+        return mkdir_1.mkdir.call(this, dir, options);
+    }
+}
+exports.PoweredFileSystem = PoweredFileSystem;

package/dist/powered-file-system.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/powered-file-system.test.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const index_1 = require("./index");
+/**
+ * Verifies constructor path resolution semantics for the main API surface.
+ */
+(0, node_test_1.describe)('#constructor: new PoweredFileSystem(pwd?)', () => {
+    (0, node_test_1.it)('Positive: An empty path must match the context of the cwd', () => {
+        const { pwd } = new index_1.PoweredFileSystem();
+        (0, node_assert_1.default)(pwd === process.cwd());
+    });
+    (0, node_test_1.it)('Positive: Absolute path must match the context of the pwd', () => {
+        const { pwd } = new index_1.PoweredFileSystem(__dirname);
+        (0, node_assert_1.default)(pwd === __dirname);
+    });
+});

package/dist/recurse-io-sync.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Synchronous counterpart of the recursive chmod implementation.
+ */
+export declare function chmodSync(src: string, mode: number): void;
+/**
+ * Synchronous counterpart of the recursive chown implementation.
+ */
+export declare function chownSync(src: string, uid: number, gid: number): void;
+/**
+ * Synchronously copies a file system node into the target directory.
+ */
+export declare function copySync(src: string, dir: string, umask: number): void;
+/**
+ * Synchronously removes files, directories, and symlinks without following links.
+ */
+export declare function removeSync(src: string): void;
+/**
+ * Synchronously creates a directory tree using permissions derived from umask.
+ */
+export declare function mkdirSync(dir: string, umask: number): void;

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

@@ -3,21 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mkdirSync = exports.removeSync = exports.copySync = exports.chownSync = exports.chmodSync = void 0;
+exports.chmodSync = chmodSync;
+exports.chownSync = chownSync;
+exports.copySync = copySync;
+exports.removeSync = removeSync;
+exports.mkdirSync = mkdirSync;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const { sep } = node_path_1.default;
+/**
+ * Synchronous counterpart of the recursive chmod implementation.
+ */
 function chmodSync(src, mode) {
     const stats = node_fs_1.default.statSync(src);
     if (stats.isDirectory()) {
         const list = node_fs_1.default.readdirSync(src);
         for (const loc of list) {
-            chmodSync(`${src}${sep}${loc}`, mode);
+            chmodSync(node_path_1.default.join(src, loc), mode);
         }
     }
     node_fs_1.default.chmodSync(src, mode);
 }
-exports.chmodSync = chmodSync;
+/**
+ * Synchronous counterpart of the recursive chown implementation.
+ */
 function chownSync(src, uid, gid) {
     const stats = node_fs_1.default.statSync(src);
     if (uid === 0) {
@@ -29,38 +37,46 @@ function chownSync(src, uid, gid) {
     if (stats.isDirectory()) {
         const list = node_fs_1.default.readdirSync(src);
         for (const loc of list) {
-            chownSync(`${src}${sep}${loc}`, uid, gid);
+            chownSync(node_path_1.default.join(src, loc), uid, gid);
         }
     }
     node_fs_1.default.chownSync(src, uid, gid);
 }
-exports.chownSync = chownSync;
+/**
+ * Synchronously copies a file system node into the target directory.
+ */
 function copySync(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);
+        const loc = node_path_1.default.basename(src);
+        const mode = 0o777 & ~umask;
+        dir = node_path_1.default.join(dir, loc);
+        node_fs_1.default.mkdirSync(dir, { mode });
         for (const loc of list) {
-            copySync(`${src}${sep}${loc}`, dir, umask);
+            copySync(node_path_1.default.join(src, loc), dir, umask);
         }
     }
     else {
         const loc = node_path_1.default.basename(src);
-        const use = `${dir}${sep}${loc}`;
+        const use = node_path_1.default.join(dir, loc);
         node_fs_1.default.copyFileSync(src, use);
+        node_fs_1.default.chmodSync(use, 0o666 & ~umask);
     }
 }
-exports.copySync = copySync;
+/**
+ * Synchronously removes files, directories, and symlinks without following links.
+ */
 function removeSync(src) {
-    const stats = node_fs_1.default.statSync(src);
+    const stats = node_fs_1.default.lstatSync(src);
+    if (stats.isSymbolicLink()) {
+        node_fs_1.default.unlinkSync(src);
+        return;
+    }
     if (stats.isDirectory()) {
         const list = node_fs_1.default.readdirSync(src);
         for (const loc of list) {
-            removeSync(`${src}${sep}${loc}`);
+            removeSync(node_path_1.default.join(src, loc));
         }
         node_fs_1.default.rmdirSync(src);
     }
@@ -68,26 +84,10 @@ function removeSync(src) {
         node_fs_1.default.unlinkSync(src);
     }
 }
-exports.removeSync = removeSync;
+/**
+ * Synchronously creates a directory tree using permissions derived from umask.
+ */
 function mkdirSync(dir, umask) {
-    const mode = 0o777 - umask;
-    const cwd = process.cwd();
-    let use = '';
-    if (dir.indexOf(cwd) === 0) {
-        use = cwd;
-        dir = dir.substring(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 });
-        }
-        catch (err) {
-            if (err.errno !== -17) {
-                throw err;
-            }
-        }
-    }
+    const mode = 0o777 & ~umask;
+    node_fs_1.default.mkdirSync(dir, { recursive: true, mode });
 }
-exports.mkdirSync = mkdirSync;

package/dist/{src/recurse-io.d.ts → recurse-io.d.ts}

@@ -1,7 +1,21 @@
-/// <reference types="node" />
 import { NoParamCallback } from 'node:fs';
+/**
+ * Applies chmod depth-first so directories are updated after their contents.
+ */
 export declare function chmod(src: string, mode: number, callback: NoParamCallback): void;
+/**
+ * Applies ownership recursively while preserving current values when uid/gid are omitted.
+ */
 export declare function chown(src: string, uid: number, gid: number, callback: NoParamCallback): void;
+/**
+ * Copies a file system node into the target directory, creating directories as needed.
+ */
 export declare function copy(src: string, dir: string, umask: number, callback: NoParamCallback): void;
+/**
+ * Removes files, directories, and symlinks without following symbolic links.
+ */
 export declare function remove(src: string, callback: NoParamCallback): void;
+/**
+ * Creates a directory tree with the permissions derived from the provided umask.
+ */
 export declare function mkdir(dir: string, umask: number, callback: NoParamCallback): void;

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

@@ -3,16 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mkdir = exports.remove = exports.copy = exports.chown = exports.chmod = void 0;
+exports.chmod = chmod;
+exports.chown = chown;
+exports.copy = copy;
+exports.remove = remove;
+exports.mkdir = mkdir;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const { sep } = node_path_1.default;
+/**
+ * Applies chmod depth-first so directories are updated after their contents.
+ */
 function chmod(src, mode, callback) {
     let reduce = 0;
     node_fs_1.default.stat(src, (err, stats) => {
-        if (err) {
+        if (err)
             return callback(err);
-        }
         if (stats.isDirectory()) {
             node_fs_1.default.readdir(src, (err, list) => {
                 if (err) {
@@ -21,9 +26,9 @@ function chmod(src, mode, callback) {
                 if (list.length === 0) {
                     return node_fs_1.default.chmod(src, mode, callback);
                 }
-                reduce += list.length;
+                reduce = list.length;
                 for (const loc of list) {
-                    chmod(`${src}${sep}${loc}`, mode, (err) => {
+                    chmod(node_path_1.default.join(src, loc), mode, (err) => {
                         if (err) {
                             return callback(err);
                         }
@@ -39,7 +44,9 @@ function chmod(src, mode, callback) {
         }
     });
 }
-exports.chmod = chmod;
+/**
+ * Applies ownership recursively while preserving current values when uid/gid are omitted.
+ */
 function chown(src, uid, gid, callback) {
     let reduce = 0;
     node_fs_1.default.stat(src, (err, stats) => {
@@ -60,9 +67,9 @@ function chown(src, uid, gid, callback) {
                 if (list.length === 0) {
                     return node_fs_1.default.chown(src, uid, gid, callback);
                 }
-                reduce += list.length;
+                reduce = list.length;
                 for (const loc of list) {
-                    chown(`${src}${sep}${loc}`, uid, gid, (err) => {
+                    chown(node_path_1.default.join(src, loc), uid, gid, (err) => {
                         if (err) {
                             return callback(err);
                         }
@@ -78,9 +85,10 @@ function chown(src, uid, gid, callback) {
         }
     });
 }
-exports.chown = chown;
+/**
+ * Copies a file system node into the target directory, creating directories as needed.
+ */
 function copy(src, dir, umask, callback) {
-    let reduce = 0;
     node_fs_1.default.stat(src, (err, stat) => {
         if (err) {
             return callback(err);
@@ -90,20 +98,22 @@ function copy(src, dir, umask, callback) {
                 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) => {
+                const loc = node_path_1.default.basename(src);
+                const destDir = node_path_1.default.join(dir, loc);
+                const mode = 0o777 & ~umask;
+                node_fs_1.default.mkdir(destDir, { mode }, (err) => {
                     if (err) {
+                        if (err.code === 'EEXIST') {
+                            err = new Error(`Target already exists: ${destDir}`);
+                        }
                         return callback(err);
                     }
-                    if (reduce === 0) {
+                    if (list.length === 0) {
                         return callback(null);
                     }
-                    for (const loc of list) {
-                        copy(`${src}${sep}${loc}`, dir, umask, (err) => {
+                    let reduce = list.length;
+                    for (const item of list) {
+                        copy(node_path_1.default.join(src, item), destDir, umask, (err) => {
                             if (err) {
                                 return callback(err);
                             }
@@ -116,38 +126,42 @@ function copy(src, dir, umask, callback) {
             });
         }
         else {
-            const mode = 0o666 - umask;
             const loc = node_path_1.default.basename(src);
+            const dest = node_path_1.default.join(dir, loc);
+            const mode = 0o666 & ~umask;
             const readStream = node_fs_1.default.createReadStream(src);
-            const writeStream = node_fs_1.default.createWriteStream(`${dir}${sep}${loc}`, {
-                mode
-            });
+            const writeStream = node_fs_1.default.createWriteStream(dest, { mode });
             readStream.on('error', callback);
             writeStream.on('error', callback);
             writeStream.on('close', () => {
-                callback(null);
+                node_fs_1.default.chmod(dest, mode, callback);
             });
             readStream.pipe(writeStream);
         }
     });
 }
-exports.copy = copy;
+/**
+ * Removes files, directories, and symlinks without following symbolic links.
+ */
 function remove(src, callback) {
-    node_fs_1.default.stat(src, (err, stat) => {
+    node_fs_1.default.lstat(src, (err, stat) => {
         if (err) {
             return callback(err);
         }
+        if (stat.isSymbolicLink()) {
+            return node_fs_1.default.unlink(src, callback);
+        }
         if (stat.isDirectory()) {
             node_fs_1.default.readdir(src, (err, list) => {
                 if (err) {
                     return callback(err);
                 }
-                let reduce = list.length;
-                if (reduce === 0) {
+                if (list.length === 0) {
                     return node_fs_1.default.rmdir(src, callback);
                 }
+                let reduce = list.length;
                 for (const loc of list) {
-                    remove(`${src}${sep}${loc}`, (err) => {
+                    remove(node_path_1.default.join(src, loc), (err) => {
                         if (err) {
                             return callback(err);
                         }
@@ -163,35 +177,15 @@ function remove(src, callback) {
         }
     });
 }
-exports.remove = remove;
+/**
+ * Creates a directory tree with the permissions derived from the provided umask.
+ */
 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;
+    const mode = 0o777 & ~umask;
+    node_fs_1.default.mkdir(dir, { recursive: true, mode }, (err) => {
+        if (err && err.code !== 'EEXIST') {
+            return callback(err);
         }
         callback(null);
-    };
-    let use = '';
-    if (dir.indexOf(cwd) === 0) {
-        use = cwd;
-        dir = dir.substring(cwd.length);
-    }
-    const files = dir.split(sep);
-    const mode = 0o777 - umask;
-    const iter = sequence(use, files, mode);
-    iter.next();
-    iter.next(iter);
+    });
 }
-exports.mkdir = mkdir;

package/dist/suite.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/suite.test.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 });
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Recursively collects compiled test files emitted into `dist/`.
+ */
+function collectTestFiles(dir) {
+    let files = [];
+    for (const entry of node_fs_1.default.readdirSync(dir)) {
+        const fullPath = node_path_1.default.join(dir, entry);
+        const stat = node_fs_1.default.statSync(fullPath);
+        if (stat.isDirectory()) {
+            if (entry === 'src' || entry === 'test') {
+                continue;
+            }
+            files = files.concat(collectTestFiles(fullPath));
+        }
+        else if (/\.test\.js$/.test(entry)) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+// The compiled output directory is the root for the test runner.
+const distDir = node_path_1.default.resolve(__dirname);
+// The runner skips itself and forwards the rest to Node's native test harness.
+const testFiles = collectTestFiles(distDir).filter((file) => file !== __filename);
+if (!testFiles.length) {
+    console.warn("⚠️  No test files found in dist/");
+    process.exit(0);
+}
+const { status } = (0, node_child_process_1.spawnSync)(process.execPath, ['--test', ...testFiles], {
+    stdio: 'inherit'
+});
+process.exitCode = status ?? 1;

package/dist/test-utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Lightweight in-memory-like description of a temporary file system tree.
+ */
+export interface Iframe {
+    [key: string]: any;
+}
+/**
+ * Creates an isolated temporary directory for a single test case.
+ */
+export declare function createTmpDir(): string;
+/**
+ * Materializes a test fixture tree on disk from a declarative frame description.
+ */
+export declare function fmock(frame: Iframe): void;
+/**
+ * Removes the temporary fixture tree while resetting restrictive permissions first.
+ */
+export declare function restore(tmpDir: string): void;

package/dist/test-utils.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTmpDir = createTmpDir;
+exports.fmock = fmock;
+exports.restore = restore;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Creates an isolated temporary directory for a single test case.
+ */
+function createTmpDir() {
+    return node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'pwd-fs-'));
+}
+/**
+ * Materializes a test fixture tree on disk from a declarative frame description.
+ */
+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') {
+            let type;
+            if (process.platform === 'win32') {
+                const stats = node_fs_1.default.lstatSync(value.target);
+                type = stats.isDirectory() ? 'junction' : 'file';
+            }
+            node_fs_1.default.symlinkSync(value.target, src, type);
+        }
+    }
+}
+/**
+ * Removes the temporary fixture tree while resetting restrictive permissions first.
+ */
+function restore(tmpDir) {
+    const removeRecursive = (src) => {
+        if (node_fs_1.default.existsSync(src)) {
+            const stats = node_fs_1.default.lstatSync(src);
+            if (stats.isSymbolicLink()) {
+                node_fs_1.default.unlinkSync(src);
+                return;
+            }
+            node_fs_1.default.chmodSync(src, 0o755);
+            node_fs_1.default.readdirSync(src).forEach((item) => {
+                const curl = node_path_1.default.join(src, item);
+                const stats = node_fs_1.default.lstatSync(curl);
+                if (stats.isSymbolicLink()) {
+                    node_fs_1.default.unlinkSync(curl);
+                }
+                else if (stats.isDirectory()) {
+                    removeRecursive(curl);
+                }
+                else {
+                    node_fs_1.default.chmodSync(curl, 0o666);
+                    node_fs_1.default.unlinkSync(curl);
+                }
+            });
+            node_fs_1.default.rmdirSync(src);
+        }
+    };
+    removeRecursive(tmpDir);
+}