pwd-fs 3.3.0 → 3.3.5

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}

@@ -10,6 +10,9 @@ exports.removeSync = removeSync;
 exports.mkdirSync = mkdirSync;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Synchronous counterpart of the recursive chmod implementation.
+ */
 function chmodSync(src, mode) {
     const stats = node_fs_1.default.statSync(src);
     if (stats.isDirectory()) {
@@ -20,6 +23,9 @@ function chmodSync(src, mode) {
     }
     node_fs_1.default.chmodSync(src, mode);
 }
+/**
+ * Synchronous counterpart of the recursive chown implementation.
+ */
 function chownSync(src, uid, gid) {
     const stats = node_fs_1.default.statSync(src);
     if (uid === 0) {
@@ -36,14 +42,17 @@ function chownSync(src, uid, gid) {
     }
     node_fs_1.default.chownSync(src, uid, gid);
 }
+/**
+ * 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 loc = node_path_1.default.basename(src);
-        const mode = 0o777 - umask;
+        const mode = 0o777 & ~umask;
         dir = node_path_1.default.join(dir, loc);
-        node_fs_1.default.mkdirSync(dir, mode);
+        node_fs_1.default.mkdirSync(dir, { mode });
         for (const loc of list) {
             copySync(node_path_1.default.join(src, loc), dir, umask);
         }
@@ -52,10 +61,18 @@ function copySync(src, dir, umask) {
         const loc = node_path_1.default.basename(src);
         const use = node_path_1.default.join(dir, loc);
         node_fs_1.default.copyFileSync(src, use);
+        node_fs_1.default.chmodSync(use, 0o666 & ~umask);
     }
 }
+/**
+ * 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) {
@@ -67,25 +84,10 @@ function removeSync(src) {
         node_fs_1.default.unlinkSync(src);
     }
 }
+/**
+ * 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(node_path_1.default.sep).slice(1);
-    for (const loc of ways) {
-        use = node_path_1.default.join(use, loc);
-        try {
-            node_fs_1.default.mkdirSync(use, { mode });
-        }
-        catch (err) {
-            if (err.code !== 'EEXIST') {
-                throw err;
-            }
-        }
-    }
+    const mode = 0o777 & ~umask;
+    node_fs_1.default.mkdirSync(dir, { recursive: true, mode });
 }
-//# sourceMappingURL=recurse-io-sync.js.map

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

@@ -1,6 +1,21 @@
 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}

@@ -10,6 +10,9 @@ exports.remove = remove;
 exports.mkdir = mkdir;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+/**
+ * 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) => {
@@ -41,6 +44,9 @@ function chmod(src, mode, callback) {
         }
     });
 }
+/**
+ * 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) => {
@@ -79,6 +85,9 @@ function chown(src, uid, gid, callback) {
         }
     });
 }
+/**
+ * Copies a file system node into the target directory, creating directories as needed.
+ */
 function copy(src, dir, umask, callback) {
     node_fs_1.default.stat(src, (err, stat) => {
         if (err) {
@@ -91,7 +100,7 @@ function copy(src, dir, umask, callback) {
                 }
                 const loc = node_path_1.default.basename(src);
                 const destDir = node_path_1.default.join(dir, loc);
-                const mode = 0o777 - umask;
+                const mode = 0o777 & ~umask;
                 node_fs_1.default.mkdir(destDir, { mode }, (err) => {
                     if (err) {
                         if (err.code === 'EEXIST') {
@@ -119,21 +128,29 @@ function copy(src, dir, umask, callback) {
         else {
             const loc = node_path_1.default.basename(src);
             const dest = node_path_1.default.join(dir, loc);
-            const mode = 0o666 - umask;
+            const mode = 0o666 & ~umask;
             const readStream = node_fs_1.default.createReadStream(src);
             const writeStream = node_fs_1.default.createWriteStream(dest, { mode });
             readStream.on('error', callback);
             writeStream.on('error', callback);
-            writeStream.on('close', () => callback(null));
+            writeStream.on('close', () => {
+                node_fs_1.default.chmod(dest, mode, callback);
+            });
             readStream.pipe(writeStream);
         }
     });
 }
+/**
+ * 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) {
@@ -160,30 +177,15 @@ function remove(src, callback) {
         }
     });
 }
+/**
+ * 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);
-    }
-    let base = '';
-    const mode = 0o777 - umask;
-    if (dir.startsWith(cwd)) {
-        base = cwd;
-        dir = dir.slice(cwd.length);
-    }
-    const parts = dir.split(node_path_1.default.sep).filter(Boolean);
-    function next(index) {
-        if (index >= parts.length) {
-            return callback(null);
+    const mode = 0o777 & ~umask;
+    node_fs_1.default.mkdir(dir, { recursive: true, mode }, (err) => {
+        if (err && err.code !== 'EEXIST') {
+            return callback(err);
         }
-        base = node_path_1.default.join(base, parts[index]);
-        node_fs_1.default.mkdir(base, { mode }, (err) => {
-            if (err && err.code !== 'EEXIST') {
-                return callback(err);
-            }
-            next(index + 1);
-        });
-    }
-    next(0);
+        callback(null);
+    });
 }
-//# sourceMappingURL=recurse-io.js.map

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);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pwd-fs",
-  "version": "3.3.0",
-  "description": "Extend the file system the capabilities of declaring the present working directory and recursive execution",
+  "version": "3.3.5",
+  "description": "Path-aware file system utilities with scoped working directories and recursive operations",
   "keywords": [
     "umask",
     "test",
@@ -24,24 +24,41 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git@github.com:woodger/pwd-fs.git"
+    "url": "https://github.com/woodger/pwd-fs.git"
+  },
+  "homepage": "https://github.com/woodger/pwd-fs#readme",
+  "bugs": {
+    "url": "https://github.com/woodger/pwd-fs/issues"
   },
   "engines": {
     "node": ">=13.2.0"
   },
-  "main": "./dist/src/index.js",
-  "types": "./dist/src/index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "readme.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc",
-    "test": "mocha ./dist/test"
+    "lint": "eslint src",
+    "test": "node ./dist/suite.test.js"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@types/chance": "^1.1.7",
-    "@types/mocha": "^10.0.10",
     "@types/node": "^24.5.1",
     "chance": "^1.1.13",
-    "expect": "^30.1.2",
-    "mocha": "^11.7.2",
-    "typescript": "^5.9.2"
+    "eslint": "^10.1.0",
+    "globals": "^17.4.0",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.57.2"
   }
 }