pwd-fs 3.1.4 → 3.2.1

package/src/powered-file-system.ts

@@ -1,12 +1,15 @@
-import fs from 'node:fs';
+import fs, { NoParamCallback } from 'node:fs';
 import path from 'node:path';
-import recurse, { Files, NoParamCallback } from './recurse-io';
-import recurseSync from './recurse-io-sync';
+import { chmod, chown, copy, remove, mkdir } from './recurse-io';
+import { chmodSync, chownSync, copySync, removeSync, mkdirSync } from './recurse-io-sync';
+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,
@@ -14,38 +17,6 @@ export interface IConstants {
   x: number
 }
 
-const permissions: number[] = [
-  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
-];
-
-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'.`
-    );
-  }
-
-  let umask = 0o000;
-
-  for (const flag of permissions) {
-    if (mode & flag) {
-      umask += flag;
-    }
-  }
-
-  return umask;
-}
-
 export class PoweredFileSystem {
   readonly pwd: string;
 
@@ -133,11 +104,11 @@ export class PoweredFileSystem {
     src = this.resolve(src);
 
     if (sync) {
-      return recurseSync.chmod(src, mode);
+      return chmodSync(src, mode);
     }
 
     return new Promise<void>((resolve, reject) => {
-      recurse.chmod(src, mode, (err) => {
+      chmod(src, mode, (err) => {
         if (err) {
           return reject(err);
         }
@@ -147,23 +118,27 @@ export class PoweredFileSystem {
     });
   }
 
-  chown(src: string, uid: number, gid: number, options: {
-    sync: true
+  chown(src: string, options: {
+    sync: true,
+    uid?: number,
+    gid?: number
   }): void;
 
-  chown(src: string, uid: number, gid: number, options?: {
-    sync?: false
+  chown(src: string, options?: {
+    sync?: false,
+    uid?: number,
+    gid?: number
   }): Promise<void>;
 
-  chown(src: string, uid: number, gid: number, { sync = false }: { sync?: boolean } = {}) {
+  chown(src: string, { sync = false, uid = 0, gid = 0 }: { sync?: boolean, uid?: number, gid?: number } = {}) {
     src = this.resolve(src);
 
     if (sync) {
-      return recurseSync.chown(src, uid, gid);
+      return chownSync(src, uid, gid);
     }
 
     return new Promise<void>((resolve, reject) => {
-      recurse.chown(src, uid, gid, (err) => {
+      chown(src, uid, gid, (err) => {
         if (err) {
           return reject(err);
         }
@@ -218,11 +193,11 @@ export class PoweredFileSystem {
     dir = this.resolve(dir);
     
     if (sync) {
-      return recurseSync.copy(src, dir, umask);
+      return copySync(src, dir, umask);
     }
 
     return new Promise<void>((resolve, reject) => {
-      recurse.copy(src, dir, umask, (err) => {
+      copy(src, dir, umask, (err) => {
         if (err) {
           return reject(err);
         }
@@ -271,17 +246,23 @@ export class PoweredFileSystem {
     src = this.resolve(src);
 
     if (sync) {
-      return recurseSync.remove(src);
+      removeSync(src);
     }
 
     return new Promise<void>((resolve, reject) => {
-      recurse.remove(src, (err) => {
+      const callback: NoParamCallback = (err) => {
         if (err) {
           return reject(err);
         }
 
         resolve();
-      });
+      };
+
+      if ('rm' in fs) {
+        return fs.rm(src, { recursive: true }, callback);
+      }
+      
+      remove(src, callback);
     });
   }
 
@@ -400,6 +381,9 @@ export class PoweredFileSystem {
     });
   }
 
+  /**
+  * @deprecated The method should not be used
+  */
   append(src: string, data: Buffer, options: {
     sync: true,
     encoding: null,
@@ -407,6 +391,9 @@ export class PoweredFileSystem {
     flag?: Flag
   }): void;
 
+  /**
+  * @deprecated The method should not be used
+  */
   append(src: string, data: string, options: {
     sync: true,
     encoding?: BufferEncoding,
@@ -414,6 +401,9 @@ export class PoweredFileSystem {
     flag?: Flag
   }): void;
 
+  /**
+  * @deprecated The method should not be used
+  */
   append(src: string, data: Buffer, options: {
     sync?: false,
     encoding: null,
@@ -421,6 +411,9 @@ export class PoweredFileSystem {
     flag?: Flag
   }): Promise<void>;
 
+  /**
+  * @deprecated The method should not be used
+  */
   append(src: string, data: string, options?: {
     sync?: false,
     encoding?: BufferEncoding,
@@ -428,6 +421,9 @@ export class PoweredFileSystem {
     flag?: Flag
   }): Promise<void>;
 
+  /**
+  * @deprecated The method should not be used
+  */
   append(src: string, data: Buffer | string, { sync = false, encoding = 'utf8', umask = 0o000, flag = 'a' }: {
     sync?: boolean,
     encoding?: BufferEncoding | null,
@@ -511,11 +507,11 @@ export class PoweredFileSystem {
     dir = this.resolve(dir);
 
     if (sync) {
-      return recurseSync.mkdir(dir, umask);
+      return mkdirSync(dir, umask);
     }
 
     return new Promise<void>((resolve, reject) => {
-      recurse.mkdir(dir, umask, (err) => {
+      mkdir(dir, umask, (err) => {
         if (err) {
           return reject(err);
         }
@@ -524,4 +520,4 @@ export class PoweredFileSystem {
       });
     });
   }
-}
+}

package/src/recurse-io-sync.ts

@@ -3,35 +3,43 @@ import path from 'node:path';
 
 const { sep } = path;
 
-function chmod(src: string, mode: number) {
-  const stat = fs.statSync(src);
+export function chmodSync(src: string, mode: number) {
+  const stats = fs.statSync(src);
 
-  if (stat.isDirectory()) {
+  if (stats.isDirectory()) {
     const list = fs.readdirSync(src);
 
     for (const loc of list) {
-      chmod(`${src}${sep}${loc}`, mode);
+      chmodSync(`${src}${sep}${loc}`, mode);
     }
   }
 
   fs.chmodSync(src, mode);
 }
 
-function chown(src: string, uid: number, gid: number) {
-  const stat = fs.statSync(src);
+export function chownSync(src: string, uid: number, gid: number) {
+  const stats = fs.statSync(src);
 
-  if (stat.isDirectory()) {
+  if (uid === 0) {
+    uid = stats.uid;
+  }
+
+  if (gid === 0) {
+    gid = stats.gid;
+  }
+
+  if (stats.isDirectory()) {
     const list = fs.readdirSync(src);
 
     for (const loc of list) {
-      chown(`${src}${sep}${loc}`, uid, gid);
+      chownSync(`${src}${sep}${loc}`, uid, gid);
     }
   }
 
   fs.chownSync(src, uid, gid);
 }
 
-function copy(src: string, dir: string, umask: number) {
+export function copySync(src: string, dir: string, umask: number) {
   const stat = fs.statSync(src);
 
   if (stat.isDirectory()) {
@@ -45,7 +53,7 @@ function copy(src: string, dir: string, umask: number) {
     fs.mkdirSync(dir, mode);
 
     for (const loc of list) {
-      copy(`${src}${sep}${loc}`, dir, umask);
+      copySync(`${src}${sep}${loc}`, dir, umask);
     }
   }
   else {
@@ -56,14 +64,14 @@ function copy(src: string, dir: string, umask: number) {
   }
 }
 
-function remove(src: string) {
-  const stat = fs.statSync(src);
+export function removeSync(src: string) {
+  const stats = fs.statSync(src);
 
-  if (stat.isDirectory()) {
+  if (stats.isDirectory()) {
     const list = fs.readdirSync(src);
 
     for (const loc of list) {
-      remove(`${src}${sep}${loc}`);
+      removeSync(`${src}${sep}${loc}`);
     }
 
     fs.rmdirSync(src);
@@ -73,14 +81,14 @@ function remove(src: string) {
   }
 }
 
-function mkdir(dir: string, umask: number) {
+export function mkdirSync(dir: string, umask: number) {
   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);
@@ -98,11 +106,3 @@ function mkdir(dir: string, umask: number) {
     }
   }
 }
-
-export default {
-  chmod,
-  chown,
-  copy,
-  remove,
-  mkdir
-}

package/src/recurse-io.ts

@@ -1,20 +1,19 @@
-import fs from 'node:fs';
+import fs, { NoParamCallback } from 'node:fs';
 import path from 'node:path';
 
-export type Files = Array<string>;
-export type NoParamCallback = fs.NoParamCallback;
+type Files = Array<string>;
 
 const { sep } = path;
 
-function chmod(src: string, mode: number, callback: NoParamCallback) {
+export function chmod(src: string, mode: number, callback: NoParamCallback) {
   let reduce = 0;
 
-  fs.stat(src, (err, stat) => {
+  fs.stat(src, (err, stats) => {
     if (err) {
       return callback(err);
     }
 
-    if (stat.isDirectory()) {
+    if (stats.isDirectory()) {
       fs.readdir(src, (err, list) => {
         if (err) {
           return callback(err);
@@ -45,7 +44,7 @@ function chmod(src: string, mode: number, callback: NoParamCallback) {
   });
 }
 
-function chown(src: string, uid: number, gid: number, callback: NoParamCallback) {
+export function chown(src: string, uid: number, gid: number, callback: NoParamCallback) {
   let reduce = 0;
 
   fs.stat(src, (err, stats) => {
@@ -53,6 +52,14 @@ function chown(src: string, uid: number, gid: number, callback: NoParamCallback)
       return callback(err);
     }
 
+    if (uid === 0) {
+      uid = stats.uid;
+    }
+
+    if (gid === 0) {
+      gid = stats.gid;
+    }
+
     if (stats.isDirectory()) {
       fs.readdir(src, (err, list) => {
         if (err) {
@@ -84,7 +91,7 @@ function chown(src: string, uid: number, gid: number, callback: NoParamCallback)
   });
 }
 
-function copy(src: string, dir: string, umask: number, callback: NoParamCallback) {
+export function copy(src: string, dir: string, umask: number, callback: NoParamCallback) {
   let reduce = 0;
 
   fs.stat(src, (err, stat) => {
@@ -150,7 +157,7 @@ function copy(src: string, dir: string, umask: number, callback: NoParamCallback
   });
 }
 
-function remove(src: string, callback: NoParamCallback) {
+export function remove(src: string, callback: NoParamCallback) {
   fs.stat(src, (err, stat) => {
     if (err) {
       return callback(err);
@@ -187,7 +194,7 @@ function remove(src: string, callback: NoParamCallback) {
   });
 }
 
-function mkdir(dir: string, umask: number, callback: NoParamCallback) {
+export function mkdir(dir: string, umask: number, callback: NoParamCallback) {
   const cwd = process.cwd();
 
   if (dir === cwd) {
@@ -218,7 +225,7 @@ function mkdir(dir: string, umask: number, callback: NoParamCallback) {
 
   if (dir.indexOf(cwd) === 0) {
     use = cwd;
-    dir = dir.substr(cwd.length);
+    dir = dir.substring(cwd.length);
   }
 
   const files = dir.split(sep);
@@ -229,11 +236,3 @@ function mkdir(dir: string, umask: number, callback: NoParamCallback) {
   iter.next();
   iter.next(iter);
 }
-
-export default {
-  chmod,
-  chown,
-  copy,
-  remove,
-  mkdir
-}

package/test/chown.spec.ts

@@ -5,7 +5,7 @@ import { expect } from 'expect';
 import { fmock, restore } from './__fmock';
 import { pfs } from '../src';
 
-describe('chown(src, uid, gid [, options])', () => {
+describe('chown(src, [, options])', () => {
   const chance = new Chance();
 
   beforeEach(() => {
@@ -25,7 +25,7 @@ describe('chown(src, uid, gid [, options])', () => {
   
   it('Positive: Changes the permissions of a file', async () => {
     const { uid, gid } = fs.statSync('./tmpdir/tings.txt');
-    await pfs.chown('./tmpdir/tings.txt', uid, gid);
+    await pfs.chown('./tmpdir/tings.txt', { uid, gid });
 
     assert(uid && gid);
   });
@@ -33,7 +33,7 @@ describe('chown(src, uid, gid [, options])', () => {
   
   it('Positive: Changes the permissions of a directory', async () => {
     const { uid, gid } = fs.statSync('./tmpdir/digest');
-    await pfs.chown('./tmpdir/digest', uid, gid);
+    await pfs.chown('./tmpdir/digest', { uid, gid });
 
     assert(uid && gid);
   });
@@ -44,7 +44,7 @@ describe('chown(src, uid, gid [, options])', () => {
     const { uid, gid } = fs.statSync('./tmpdir/tings.txt');
     
     await expect(async () => {
-      await pfs.chown(`./tmpdir/${guid}`, uid, gid);
+      await pfs.chown(`./tmpdir/${guid}`, { uid, gid });
     })
     .rejects
     .toThrow();
@@ -54,8 +54,10 @@ describe('chown(src, uid, gid [, options])', () => {
   it('[sync] Positive: Changes the permissions of a file', () => {
     const { uid, gid } = fs.statSync('./tmpdir/tings.txt');
 
-    pfs.chown('./tmpdir/tings.txt', uid, gid, {
-      sync: true
+    pfs.chown('./tmpdir/tings.txt', {
+      sync: true,
+      uid,
+      gid
     });
 
     assert(uid && gid);
@@ -65,8 +67,10 @@ describe('chown(src, uid, gid [, options])', () => {
   it('[sync] Positive: Changes the permissions of a directory', () => {
     const { uid, gid } = fs.statSync('./tmpdir/digest');
 
-    pfs.chown('./tmpdir/digest', uid, gid, {
-      sync: true
+    pfs.chown('./tmpdir/digest', {
+      sync: true,
+      uid,
+      gid
     });
 
     assert(uid && gid);
@@ -78,8 +82,10 @@ describe('chown(src, uid, gid [, options])', () => {
     const { uid, gid } = fs.statSync('./tmpdir/tings.txt');
     
     assert.throws(() => {
-      pfs.chown(`./tmpdir/${guid}`, uid, gid, {
-        sync: true
+      pfs.chown(`./tmpdir/${guid}`, {
+        sync: true,
+        uid,
+        gid
       });
     });
   });

package/tsconfig.json

@@ -3,7 +3,7 @@
     "lib": [
 			"es2022"
 		],
-		"module": "CommonJS",
+		"module": "commonjs",
 		"target": "es2022",
 		"moduleResolution": "node",
     "resolveJsonModule": true,
@@ -14,6 +14,6 @@
     "declaration": true,
     "noEmitOnError": true,
     "noUnusedLocals": false,
-    "outDir": "lib"
+    "outDir": "dist"
   }
 }

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

@@ -1,13 +0,0 @@
-declare function chmod(src: string, mode: number): void;
-declare function chown(src: string, uid: number, gid: number): void;
-declare function copy(src: string, dir: string, umask: number): void;
-declare function remove(src: string): void;
-declare function mkdir(dir: string, umask: number): void;
-declare const _default: {
-    chmod: typeof chmod;
-    chown: typeof chown;
-    copy: typeof copy;
-    remove: typeof remove;
-    mkdir: typeof mkdir;
-};
-export default _default;

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

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

package/lib/test/__fmock.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,40 +0,0 @@
-"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.d.ts

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

package/lib/test/append.spec.js

@@ -1,58 +0,0 @@
-"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_fs_1 = __importDefault(require("node:fs"));
-const chance_1 = __importDefault(require("chance"));
-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(() => {
-        (0, __fmock_1.fmock)({
-            './tmpdir/tings.txt': {
-                type: 'file',
-                data: 'hoodie'
-            }
-        });
-    });
-    afterEach(() => {
-        (0, __fmock_1.restore)('./tmpdir');
-    });
-    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 payload = chance.paragraph();
-        await (0, expect_1.expect)(async () => {
-            await src_1.pfs.append('./tmpdir/tings.txt', payload, {
-                flag: 'r'
-            });
-        })
-            .rejects
-            .toThrow();
-    });
-    it(`[sync] Positive: Must append content to file`, () => {
-        const payload = chance.paragraph();
-        src_1.pfs.append('./tmpdir/tings.txt', payload, {
-            sync: true
-        });
-        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,
-                flag: 'r'
-            });
-        });
-    });
-});

package/lib/test/bitmask.spec.d.ts

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

package/lib/test/bitmask.spec.js

@@ -1,26 +0,0 @@
-"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 src_1 = require("../src");
-describe('static bitmask(mode: number)', () => {
-    it('Positive: Calculate bitmask', () => {
-        (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`, () => {
-        node_assert_1.default.throws(() => {
-            // @ts-ignore
-            (0, src_1.bitmask)(null);
-        });
-    });
-});

package/lib/test/chmod.spec.d.ts

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