pwd-fs 3.1.4 → 3.2.1

package/dist/src/bitmask.d.ts

@@ -0,0 +1 @@
+export declare function bitmask(mode: number): number;

package/dist/src/bitmask.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bitmask = void 0;
+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'.`);
+    }
+    const permissions = [0o400, 0o200, 0o100, 0o040, 0o020, 0o010, 0o004, 0o002, 0o001];
+    let umask = 0o000;
+    for (const flag of permissions) {
+        if (mode & flag) {
+            umask += flag;
+        }
+    }
+    return umask;
+}
+exports.bitmask = bitmask;

package/{lib → dist}/src/powered-file-system.d.ts

@@ -1,16 +1,17 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import fs from 'node:fs';
+import { bitmask } from './bitmask';
 export type Mode = keyof IConstants;
 export type Flag = Mode | 'a';
 export type Stats = fs.Stats;
+export * from './bitmask';
 export interface IConstants {
     e: number;
     r: number;
     w: number;
     x: number;
 }
-export declare function bitmask(mode: number): number;
 export declare class PoweredFileSystem {
     readonly pwd: string;
     readonly constants: IConstants;
@@ -37,11 +38,15 @@ export declare class PoweredFileSystem {
     chmod(src: string, mode: number, options?: {
         sync?: false;
     }): Promise<void>;
-    chown(src: string, uid: number, gid: number, options: {
+    chown(src: string, options: {
         sync: true;
+        uid?: number;
+        gid?: number;
     }): void;
-    chown(src: string, uid: number, gid: number, options?: {
+    chown(src: string, options?: {
         sync?: false;
+        uid?: number;
+        gid?: number;
     }): Promise<void>;
     symlink(src: string, use: string, options: {
         sync: true;
@@ -113,24 +118,36 @@ export declare class PoweredFileSystem {
         umask?: number;
         flag?: Flag;
     }): Promise<void>;
+    /**
+    * @deprecated The method should not be used
+    */
     append(src: string, data: Buffer, options: {
         sync: true;
         encoding: null;
         umask?: number;
         flag?: Flag;
     }): void;
+    /**
+    * @deprecated The method should not be used
+    */
     append(src: string, data: string, options: {
         sync: true;
         encoding?: BufferEncoding;
         umask?: number;
         flag?: Flag;
     }): void;
+    /**
+    * @deprecated The method should not be used
+    */
     append(src: string, data: Buffer, options: {
         sync?: false;
         encoding: null;
         umask?: number;
         flag?: Flag;
     }): Promise<void>;
+    /**
+    * @deprecated The method should not be used
+    */
     append(src: string, data: string, options?: {
         sync?: false;
         encoding?: BufferEncoding;

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

@@ -1,38 +1,29 @@
 "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 = exports.bitmask = void 0;
+exports.PoweredFileSystem = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const recurse_io_1 = __importDefault(require("./recurse-io"));
-const recurse_io_sync_1 = __importDefault(require("./recurse-io-sync"));
-const permissions = [
-    0o400, // OWNER_READ
-    0o200, // OWNER_WRITE
-    0o100, // OWNER_EXECUTE
-    0o040, // GROUP_READ
-    0o020, // GROUP_WRITE
-    0o010, // GROUP_EXECUTE
-    0o004, // OTHERS_READ
-    0o002, // OTHERS_WRITE
-    0o001 // OTHERS_EXECUTE
-];
-function bitmask(mode) {
-    const type = typeof mode;
-    if (type !== 'number') {
-        throw new Error(`Argument of type '${type}' is not assignable to parameter of type 'number'.`);
-    }
-    let umask = 0o000;
-    for (const flag of permissions) {
-        if (mode & flag) {
-            umask += flag;
-        }
-    }
-    return umask;
-}
-exports.bitmask = bitmask;
+const recurse_io_1 = require("./recurse-io");
+const recurse_io_sync_1 = require("./recurse-io-sync");
+const bitmask_1 = require("./bitmask");
+__exportStar(require("./bitmask"), exports);
 class PoweredFileSystem {
     pwd;
     constants = {
@@ -41,7 +32,7 @@ class PoweredFileSystem {
         w: node_fs_1.default.constants.W_OK,
         x: node_fs_1.default.constants.X_OK
     };
-    static bitmask = bitmask;
+    static bitmask = bitmask_1.bitmask;
     constructor(pwd) {
         this.pwd = pwd ? node_path_1.default.resolve(pwd) : process.cwd();
     }
@@ -80,10 +71,10 @@ class PoweredFileSystem {
     chmod(src, mode, { sync = false } = {}) {
         src = this.resolve(src);
         if (sync) {
-            return recurse_io_sync_1.default.chmod(src, mode);
+            return (0, recurse_io_sync_1.chmodSync)(src, mode);
         }
         return new Promise((resolve, reject) => {
-            recurse_io_1.default.chmod(src, mode, (err) => {
+            (0, recurse_io_1.chmod)(src, mode, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -91,13 +82,13 @@ class PoweredFileSystem {
             });
         });
     }
-    chown(src, uid, gid, { sync = false } = {}) {
+    chown(src, { sync = false, uid = 0, gid = 0 } = {}) {
         src = this.resolve(src);
         if (sync) {
-            return recurse_io_sync_1.default.chown(src, uid, gid);
+            return (0, recurse_io_sync_1.chownSync)(src, uid, gid);
         }
         return new Promise((resolve, reject) => {
-            recurse_io_1.default.chown(src, uid, gid, (err) => {
+            (0, recurse_io_1.chown)(src, uid, gid, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -124,10 +115,10 @@ class PoweredFileSystem {
         src = this.resolve(src);
         dir = this.resolve(dir);
         if (sync) {
-            return recurse_io_sync_1.default.copy(src, dir, umask);
+            return (0, recurse_io_sync_1.copySync)(src, dir, umask);
         }
         return new Promise((resolve, reject) => {
-            recurse_io_1.default.copy(src, dir, umask, (err) => {
+            (0, recurse_io_1.copy)(src, dir, umask, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -153,15 +144,19 @@ class PoweredFileSystem {
     remove(src, { sync = false } = {}) {
         src = this.resolve(src);
         if (sync) {
-            return recurse_io_sync_1.default.remove(src);
+            (0, recurse_io_sync_1.removeSync)(src);
         }
         return new Promise((resolve, reject) => {
-            recurse_io_1.default.remove(src, (err) => {
+            const callback = (err) => {
                 if (err) {
                     return reject(err);
                 }
                 resolve();
-            });
+            };
+            if ('rm' in node_fs_1.default) {
+                return node_fs_1.default.rm(src, { recursive: true }, callback);
+            }
+            (0, recurse_io_1.remove)(src, callback);
         });
     }
     read(src, { sync = false, encoding = 'utf8', flag = 'r' } = {}) {
@@ -207,6 +202,9 @@ class PoweredFileSystem {
             });
         });
     }
+    /**
+    * @deprecated The method should not be used
+    */
     append(src, data, { sync = false, encoding = 'utf8', umask = 0o000, flag = 'a' } = {}) {
         src = this.resolve(src);
         const mode = 0o666 - umask;
@@ -249,10 +247,10 @@ class PoweredFileSystem {
     mkdir(dir, { umask = 0o000, sync = false } = {}) {
         dir = this.resolve(dir);
         if (sync) {
-            return recurse_io_sync_1.default.mkdir(dir, umask);
+            return (0, recurse_io_sync_1.mkdirSync)(dir, umask);
         }
         return new Promise((resolve, reject) => {
-            recurse_io_1.default.mkdir(dir, umask, (err) => {
+            (0, recurse_io_1.mkdir)(dir, umask, (err) => {
                 if (err) {
                     return reject(err);
                 }

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

@@ -0,0 +1,5 @@
+export declare function chmodSync(src: string, mode: number): void;
+export declare function chownSync(src: string, uid: number, gid: number): void;
+export declare function copySync(src: string, dir: string, umask: number): void;
+export declare function removeSync(src: string): void;
+export declare function mkdirSync(dir: string, umask: number): void;

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

@@ -3,30 +3,39 @@ 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;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const { sep } = node_path_1.default;
-function chmod(src, mode) {
-    const stat = node_fs_1.default.statSync(src);
-    if (stat.isDirectory()) {
+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) {
-            chmod(`${src}${sep}${loc}`, mode);
+            chmodSync(`${src}${sep}${loc}`, mode);
         }
     }
     node_fs_1.default.chmodSync(src, mode);
 }
-function chown(src, uid, gid) {
-    const stat = node_fs_1.default.statSync(src);
-    if (stat.isDirectory()) {
+exports.chmodSync = chmodSync;
+function chownSync(src, uid, gid) {
+    const stats = node_fs_1.default.statSync(src);
+    if (uid === 0) {
+        uid = stats.uid;
+    }
+    if (gid === 0) {
+        gid = stats.gid;
+    }
+    if (stats.isDirectory()) {
         const list = node_fs_1.default.readdirSync(src);
         for (const loc of list) {
-            chown(`${src}${sep}${loc}`, uid, gid);
+            chownSync(`${src}${sep}${loc}`, uid, gid);
         }
     }
     node_fs_1.default.chownSync(src, uid, gid);
 }
-function copy(src, dir, umask) {
+exports.chownSync = chownSync;
+function copySync(src, dir, umask) {
     const stat = node_fs_1.default.statSync(src);
     if (stat.isDirectory()) {
         const list = node_fs_1.default.readdirSync(src);
@@ -36,7 +45,7 @@ function copy(src, dir, umask) {
         dir = `${dir}${sep}${loc}`;
         node_fs_1.default.mkdirSync(dir, mode);
         for (const loc of list) {
-            copy(`${src}${sep}${loc}`, dir, umask);
+            copySync(`${src}${sep}${loc}`, dir, umask);
         }
     }
     else {
@@ -45,12 +54,13 @@ function copy(src, dir, umask) {
         node_fs_1.default.copyFileSync(src, use);
     }
 }
-function remove(src) {
-    const stat = node_fs_1.default.statSync(src);
-    if (stat.isDirectory()) {
+exports.copySync = copySync;
+function removeSync(src) {
+    const stats = node_fs_1.default.statSync(src);
+    if (stats.isDirectory()) {
         const list = node_fs_1.default.readdirSync(src);
         for (const loc of list) {
-            remove(`${src}${sep}${loc}`);
+            removeSync(`${src}${sep}${loc}`);
         }
         node_fs_1.default.rmdirSync(src);
     }
@@ -58,13 +68,14 @@ function remove(src) {
         node_fs_1.default.unlinkSync(src);
     }
 }
-function mkdir(dir, umask) {
+exports.removeSync = removeSync;
+function mkdirSync(dir, umask) {
     const mode = 0o777 - umask;
     const cwd = process.cwd();
     let use = '';
     if (dir.indexOf(cwd) === 0) {
         use = cwd;
-        dir = dir.substr(cwd.length);
+        dir = dir.substring(cwd.length);
     }
     const ways = dir.split(sep).slice(1);
     for (const loc of ways) {
@@ -79,10 +90,4 @@ function mkdir(dir, umask) {
         }
     }
 }
-exports.default = {
-    chmod,
-    chown,
-    copy,
-    remove,
-    mkdir
-};
+exports.mkdirSync = mkdirSync;

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

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { NoParamCallback } from 'node:fs';
+export declare function chmod(src: string, mode: number, callback: NoParamCallback): void;
+export declare function chown(src: string, uid: number, gid: number, callback: NoParamCallback): void;
+export declare function copy(src: string, dir: string, umask: number, callback: NoParamCallback): void;
+export declare function remove(src: string, callback: NoParamCallback): void;
+export declare function mkdir(dir: string, umask: number, callback: NoParamCallback): void;

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

@@ -3,16 +3,17 @@ 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;
 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) => {
+    node_fs_1.default.stat(src, (err, stats) => {
         if (err) {
             return callback(err);
         }
-        if (stat.isDirectory()) {
+        if (stats.isDirectory()) {
             node_fs_1.default.readdir(src, (err, list) => {
                 if (err) {
                     return callback(err);
@@ -38,12 +39,19 @@ function chmod(src, mode, callback) {
         }
     });
 }
+exports.chmod = chmod;
 function chown(src, uid, gid, callback) {
     let reduce = 0;
     node_fs_1.default.stat(src, (err, stats) => {
         if (err) {
             return callback(err);
         }
+        if (uid === 0) {
+            uid = stats.uid;
+        }
+        if (gid === 0) {
+            gid = stats.gid;
+        }
         if (stats.isDirectory()) {
             node_fs_1.default.readdir(src, (err, list) => {
                 if (err) {
@@ -70,6 +78,7 @@ function chown(src, uid, gid, callback) {
         }
     });
 }
+exports.chown = chown;
 function copy(src, dir, umask, callback) {
     let reduce = 0;
     node_fs_1.default.stat(src, (err, stat) => {
@@ -122,6 +131,7 @@ function copy(src, dir, umask, callback) {
         }
     });
 }
+exports.copy = copy;
 function remove(src, callback) {
     node_fs_1.default.stat(src, (err, stat) => {
         if (err) {
@@ -153,6 +163,7 @@ function remove(src, callback) {
         }
     });
 }
+exports.remove = remove;
 function mkdir(dir, umask, callback) {
     const cwd = process.cwd();
     if (dir === cwd) {
@@ -175,7 +186,7 @@ function mkdir(dir, umask, callback) {
     let use = '';
     if (dir.indexOf(cwd) === 0) {
         use = cwd;
-        dir = dir.substr(cwd.length);
+        dir = dir.substring(cwd.length);
     }
     const files = dir.split(sep);
     const mode = 0o777 - umask;
@@ -183,10 +194,4 @@ function mkdir(dir, umask, callback) {
     iter.next();
     iter.next(iter);
 }
-exports.default = {
-    chmod,
-    chown,
-    copy,
-    remove,
-    mkdir
-};
+exports.mkdir = mkdir;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pwd-fs",
-  "version": "3.1.4",
+  "version": "3.2.1",
   "description": "Extend the file system the capabilities of declaring the present working directory and recursive execution",
   "keywords": [
     "umask",
@@ -24,16 +24,16 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/woodger/pwd-fs.git"
+    "url": "git@github.com:woodger/pwd-fs.git"
   },
   "engines": {
     "node": ">=13.2.0"
   },
-  "main": "./lib/src/index.js",
-  "types": "./lib/src/index.d.ts",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "test": "mocha ./lib/test"
+    "test": "mocha ./dist/test"
   },
   "devDependencies": {
     "@types/chance": "^1.1.6",

package/readme.md

@@ -47,7 +47,7 @@ The scope `URI` of the class methods are divided into groups.
 | URI                         | Methods                                                          |
 |-----------------------------|------------------------------------------------------------------|
 | Common (file and directory) | `chmod` `chown` `copy` `remove` `rename` `symlink` `stat` `test` |
-| File only                   | `read` `write`                                          |
+| File only                   | `read` `write`                                                   |
 | Directory only              | `mkdir` `readdir`                                                |
 
 
@@ -151,13 +151,13 @@ console.log(bitmask(mode) === 0o750); // true
 
 See manuals [chmod(2)](http://man7.org/linux/man-pages/man2/chmod.2.html)
 
-#### pfs.chown(src, uid, gid[, options])
+#### pfs.chown(src, [, options])
 
 - `src` <[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)> Absolute or relative path to the resource in the file system. Relative paths will be resolved relative to the present working directory as specified by `pfs.pwd`.
-- `uid` <[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)>
-- `gid` <[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)>
 - `options` <[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)>
   - `sync` <[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)> Synchronous execution. **Default:** `false`.
+  - `uid` <[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)> The file's new owner's user id.
+  - `gid` <[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)> The file's new group's group id.
 - returns: <[Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)> Following successful change, the `Promise` is resolved with an value with a `undefined`.
 
 Asynchronously changes owner and group of a file.

package/src/bitmask.ts

@@ -0,0 +1,20 @@
+export function bitmask(mode: number) {
+  const type = typeof mode;
+
+  if (type !== 'number') {
+    throw new Error(
+      `Argument of type '${type}' is not assignable to parameter of type 'number'.`
+    );
+  }
+
+  const permissions: number[] = [ 0o400, 0o200, 0o100, 0o040, 0o020, 0o010, 0o004, 0o002, 0o001 ];
+  let umask = 0o000;
+
+  for (const flag of permissions) {
+    if (mode & flag) {
+      umask += flag;
+    }
+  }
+
+  return umask;
+}