pwd-fs 3.1.3 → 3.2.0

package/lib/src/bitmask.d.ts

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

package/lib/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/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

@@ -1,9 +1,11 @@
 /// <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;
@@ -13,9 +15,9 @@ export interface IConstants {
 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;
@@ -36,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;
@@ -112,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/{powered-file-system.js → src/powered-file-system.js}

@@ -1,56 +1,52 @@
-'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');
-
-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
-];
+"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 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 = {
-        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_1.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 +57,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 +71,10 @@ class PoweredFileSystem {
     chmod(src, mode, { sync = false } = {}) {
         src = this.resolve(src);
         if (sync) {
-            return recurseIoSync.default.chmod(src, mode);
+            return (0, recurse_io_sync_1.chmodSync)(src, mode);
         }
         return new Promise((resolve, reject) => {
-            recurseIo.default.chmod(src, mode, (err) => {
+            (0, recurse_io_1.chmod)(src, mode, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -86,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 recurseIoSync.default.chown(src, uid, gid);
+            return (0, recurse_io_sync_1.chownSync)(src, uid, gid);
         }
         return new Promise((resolve, reject) => {
-            recurseIo.default.chown(src, uid, gid, (err) => {
+            (0, recurse_io_1.chown)(src, uid, gid, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -104,10 +100,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 +115,10 @@ class PoweredFileSystem {
         src = this.resolve(src);
         dir = this.resolve(dir);
         if (sync) {
-            return recurseIoSync.default.copy(src, dir, umask);
+            return (0, recurse_io_sync_1.copySync)(src, dir, umask);
         }
         return new Promise((resolve, reject) => {
-            recurseIo.default.copy(src, dir, umask, (err) => {
+            (0, recurse_io_1.copy)(src, dir, umask, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -134,10 +130,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,27 +144,31 @@ class PoweredFileSystem {
     remove(src, { sync = false } = {}) {
         src = this.resolve(src);
         if (sync) {
-            return recurseIoSync.default.remove(src);
+            (0, recurse_io_sync_1.removeSync)(src);
         }
         return new Promise((resolve, reject) => {
-            recurseIo.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' } = {}) {
         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 +183,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
@@ -202,18 +202,21 @@ 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;
         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 +231,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 +247,10 @@ class PoweredFileSystem {
     mkdir(dir, { umask = 0o000, sync = false } = {}) {
         dir = this.resolve(dir);
         if (sync) {
-            return recurseIoSync.default.mkdir(dir, umask);
+            return (0, recurse_io_sync_1.mkdirSync)(dir, umask);
         }
         return new Promise((resolve, reject) => {
-            recurseIo.default.mkdir(dir, umask, (err) => {
+            (0, recurse_io_1.mkdir)(dir, umask, (err) => {
                 if (err) {
                     return reject(err);
                 }
@@ -256,5 +259,4 @@ class PoweredFileSystem {
         });
     }
 }
-
 exports.PoweredFileSystem = PoweredFileSystem;

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

@@ -1,13 +1,5 @@
-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;
+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/src/recurse-io-sync.js

@@ -0,0 +1,93 @@
+"use strict";
+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 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);
+        }
+    }
+    node_fs_1.default.chmodSync(src, mode);
+}
+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) {
+            chownSync(`${src}${sep}${loc}`, uid, gid);
+        }
+    }
+    node_fs_1.default.chownSync(src, uid, gid);
+}
+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);
+        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);
+        for (const loc of list) {
+            copySync(`${src}${sep}${loc}`, dir, umask);
+        }
+    }
+    else {
+        const loc = node_path_1.default.basename(src);
+        const use = `${dir}${sep}${loc}`;
+        node_fs_1.default.copyFileSync(src, use);
+    }
+}
+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) {
+            removeSync(`${src}${sep}${loc}`);
+        }
+        node_fs_1.default.rmdirSync(src);
+    }
+    else {
+        node_fs_1.default.unlinkSync(src);
+    }
+}
+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.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;
+            }
+        }
+    }
+}
+exports.mkdirSync = mkdirSync;

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

@@ -1,17 +1,7 @@
 /// <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;
+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;