pwd-fs 2.4.2 → 3.1.4

package/.travis.yml

@@ -1,10 +1,9 @@
 language: node_js
 node_js:
-  - 8
-  - 10
-  - 12
   - 14
   - 16
+  - 18
+  - 20
 install:
   - yarn
   - yarn global add nyc coveralls

package/appveyor.yml

@@ -1,15 +1,13 @@
 environment:
   matrix:
-    - nodejs_version: 8
-    - nodejs_version: 10
-    - nodejs_version: 12
     - nodejs_version: 14
     - nodejs_version: 16
+    - nodejs_version: 18
+    - nodejs_version: 20
 install:
   - ps: Install-Product node $env:nodejs_version
   - npm config set loglevel warn
   - npm install --silent
-  - npm install -g typescript
 test_script:
   - npm run build
   - npm test

package/lib/src/index.d.ts

@@ -1,186 +1,4 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import fs from 'fs';
-export declare type Mode = 'e' | 'r' | 'w' | 'x';
-export declare type Flag = Mode | 'a';
-export interface Constants {
-    e: number;
-    r: number;
-    w: number;
-    x: number;
-}
-export default class PoweredFileSystem {
-    readonly pwd: string;
-    readonly constants: Constants;
-    constructor(pwd?: string);
-    test(src: string, options: {
-        sync: true;
-        resolve?: boolean;
-        flag?: Mode;
-    }): boolean;
-    test(src: string, options?: {
-        sync?: false;
-        resolve?: boolean;
-        flag?: Mode;
-    }): Promise<boolean>;
-    stat(src: string, options: {
-        sync: true;
-        resolve?: boolean;
-    }): fs.Stats;
-    stat(src: string, options?: {
-        sync?: false;
-        resolve?: boolean;
-    }): Promise<fs.Stats>;
-    chmod(src: string, mode: number, options: {
-        sync: true;
-        resolve?: boolean;
-    }): void;
-    chmod(src: string, mode: number, options?: {
-        sync?: false;
-        resolve?: boolean;
-    }): Promise<void>;
-    chown(src: string, uid: number, gid: number, options: {
-        sync: true;
-        resolve?: boolean;
-    }): void;
-    chown(src: string, uid: number, gid: number, options?: {
-        sync?: false;
-        resolve?: boolean;
-    }): Promise<void>;
-    symlink(src: string, use: string, options: {
-        sync: true;
-        resolve?: boolean;
-    }): void;
-    symlink(src: string, use: string, options?: {
-        sync?: false;
-        resolve?: boolean;
-    }): Promise<void>;
-    copy(src: string, dir: string, options: {
-        sync: true;
-        resolve?: boolean;
-        umask?: number;
-    }): void;
-    copy(src: string, dir: string, options?: {
-        sync?: false;
-        resolve?: boolean;
-        umask?: number;
-    }): Promise<void>;
-    rename(src: string, use: string, options: {
-        sync: true;
-        resolve?: boolean;
-    }): void;
-    rename(src: string, use: string, options?: {
-        sync?: false;
-        resolve?: boolean;
-    }): Promise<void>;
-    remove(src: string, options: {
-        sync: true;
-        resolve?: boolean;
-    }): void;
-    remove(src: string, options?: {
-        sync?: false;
-        resolve?: boolean;
-    }): Promise<void>;
-    read(src: string, options: {
-        sync: true;
-        resolve?: boolean;
-        encoding?: BufferEncoding;
-        flag?: Flag;
-    }): string;
-    read(src: string, options: {
-        sync: true;
-        resolve?: boolean;
-        encoding?: null;
-        flag?: Flag;
-    }): Buffer;
-    read(src: string, options: {
-        sync?: false;
-        resolve?: boolean;
-        encoding: null;
-        flag?: Flag;
-    }): Promise<Buffer>;
-    read(src: string, options?: {
-        sync?: false;
-        resolve?: boolean;
-        encoding?: BufferEncoding;
-        flag?: Flag;
-    }): Promise<string>;
-    write(src: string, data: Buffer, options: {
-        sync: true;
-        resolve?: boolean;
-        encoding: null;
-        umask?: number;
-        flag?: Flag;
-    }): void;
-    write(src: string, data: string, options: {
-        sync: true;
-        resolve?: boolean;
-        encoding?: BufferEncoding;
-        umask?: number;
-        flag?: Flag;
-    }): void;
-    write(src: string, data: Buffer, options: {
-        sync?: false;
-        resolve?: boolean;
-        encoding: null;
-        umask?: number;
-        flag?: Flag;
-    }): Promise<void>;
-    write(src: string, data: string, options?: {
-        sync?: false;
-        resolve?: boolean;
-        encoding?: BufferEncoding;
-        umask?: number;
-        flag?: Flag;
-    }): Promise<void>;
-    append(src: string, data: Buffer, options: {
-        sync: true;
-        resolve?: boolean;
-        encoding: null;
-        umask?: number;
-        flag?: Flag;
-    }): void;
-    append(src: string, data: string, options: {
-        sync: true;
-        resolve?: boolean;
-        encoding?: BufferEncoding;
-        umask?: number;
-        flag?: Flag;
-    }): void;
-    append(src: string, data: Buffer, options: {
-        sync?: false;
-        resolve?: boolean;
-        encoding: null;
-        umask?: number;
-        flag?: Flag;
-    }): Promise<void>;
-    append(src: string, data: string, options?: {
-        sync?: false;
-        resolve?: boolean;
-        encoding?: BufferEncoding;
-        umask?: number;
-        flag?: Flag;
-    }): Promise<void>;
-    readdir(dir: string, options: {
-        sync: true;
-        resolve?: boolean;
-        encoding?: BufferEncoding | null;
-    }): string[];
-    readdir(dir: string, options?: {
-        sync?: false;
-        resolve?: boolean;
-        encoding?: BufferEncoding | null;
-    }): Promise<string[]>;
-    mkdir(dir: string, options: {
-        sync: true;
-        resolve?: boolean;
-        umask?: number;
-    }): void;
-    mkdir(dir: string, options?: {
-        sync?: false;
-        resolve?: boolean;
-        umask?: number;
-    }): Promise<void>;
-    private resolve;
-    static bitmask(mode: number): number;
-}
+import { PoweredFileSystem } from './powered-file-system';
+export declare const pfs: PoweredFileSystem;
+export default PoweredFileSystem;
+export * from './powered-file-system';

package/lib/src/index.js

@@ -1,297 +1,21 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 });
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const recurse_io_1 = __importDefault(require("./recurse-io"));
-const recurse_io_sync_1 = __importDefault(require("./recurse-io-sync"));
-class PoweredFileSystem {
-    constructor(pwd) {
-        this.pwd = process.cwd();
-        this.constants = {
-            e: fs_1.default.constants.F_OK,
-            r: fs_1.default.constants.R_OK,
-            w: fs_1.default.constants.W_OK,
-            x: fs_1.default.constants.X_OK
-        };
-        if (pwd) {
-            this.pwd = path_1.default.resolve(pwd);
-        }
-    }
-    test(src, { sync = false, resolve = true, flag = 'e' } = {}) {
-        const mode = this.constants[flag];
-        if (resolve) {
-            src = path_1.default.resolve(this.pwd, src);
-        }
-        if (sync) {
-            return fs_1.default.existsSync(src);
-        }
-        return new Promise((resolve) => {
-            fs_1.default.access(src, mode, (err) => {
-                if (err) {
-                    return resolve(false);
-                }
-                resolve(true);
-            });
-        });
-    }
-    stat(src, { sync = false, resolve = true } = {}) {
-        if (resolve) {
-            src = this.resolve(src);
-        }
-        if (sync) {
-            return fs_1.default.lstatSync(src);
-        }
-        return new Promise((resolve, reject) => {
-            fs_1.default.lstat(src, (err, stats) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve(stats);
-            });
-        });
-    }
-    chmod(src, mode, { sync = false, resolve = true } = {}) {
-        if (resolve) {
-            src = this.resolve(src);
-        }
-        if (sync) {
-            return recurse_io_sync_1.default.chmod(src, mode);
-        }
-        return new Promise((resolve, reject) => {
-            recurse_io_1.default.chmod(src, mode, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
-    }
-    chown(src, uid, gid, { sync = false, resolve = true } = {}) {
-        if (resolve) {
-            src = this.resolve(src);
-        }
-        if (sync) {
-            return recurse_io_sync_1.default.chown(src, uid, gid);
-        }
-        return new Promise((resolve, reject) => {
-            recurse_io_1.default.chown(src, uid, gid, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
-    }
-    symlink(src, use, { sync = false, resolve = true } = {}) {
-        if (resolve) {
-            src = this.resolve(src);
-            use = this.resolve(use);
-        }
-        if (sync) {
-            return fs_1.default.symlinkSync(src, use);
-        }
-        return new Promise((resolve, reject) => {
-            fs_1.default.symlink(src, use, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
-    }
-    copy(src, dir, { sync = false, resolve = true, umask = 0o000 } = {}) {
-        if (resolve) {
-            src = this.resolve(src);
-            dir = this.resolve(dir);
-        }
-        if (sync) {
-            return recurse_io_sync_1.default.copy(src, dir, umask);
-        }
-        return new Promise((resolve, reject) => {
-            recurse_io_1.default.copy(src, dir, umask, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
-    }
-    rename(src, use, { sync = false, resolve = true } = {}) {
-        if (resolve) {
-            src = this.resolve(src);
-            use = this.resolve(use);
-        }
-        if (sync) {
-            return fs_1.default.renameSync(src, use);
-        }
-        return new Promise((resolve, reject) => {
-            fs_1.default.rename(src, use, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
-    }
-    remove(src, { sync = false, resolve = true } = {}) {
-        if (resolve) {
-            src = this.resolve(src);
-        }
-        if (sync) {
-            return recurse_io_sync_1.default.remove(src);
-        }
-        return new Promise((resolve, reject) => {
-            recurse_io_1.default.remove(src, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
-    }
-    read(src, { sync = false, resolve = true, encoding = 'utf8', flag = 'r' } = {}) {
-        if (resolve) {
-            src = this.resolve(src);
-        }
-        if (sync) {
-            return fs_1.default.readFileSync(src, {
-                encoding,
-                flag
-            });
-        }
-        return new Promise((resolve, reject) => {
-            fs_1.default.readFile(src, {
-                encoding,
-                flag
-            }, (err, raw) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve(raw);
-            });
-        });
-    }
-    write(src, data, { sync = false, resolve = true, encoding = 'utf8', umask = 0o000, flag = 'w' } = {}) {
-        if (resolve) {
-            src = this.resolve(src);
-        }
-        const mode = 0o666 - umask;
-        if (sync) {
-            return fs_1.default.writeFileSync(src, data, {
-                encoding,
-                mode,
-                flag
-            });
-        }
-        return new Promise((resolve, reject) => {
-            fs_1.default.writeFile(src, data, {
-                encoding,
-                mode,
-                flag
-            }, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
-    }
-    append(src, data, { sync = false, resolve = true, encoding = 'utf8', umask = 0o000, flag = 'a' } = {}) {
-        if (resolve) {
-            src = this.resolve(src);
-        }
-        const mode = 0o666 - umask;
-        if (sync) {
-            return fs_1.default.appendFileSync(src, data, {
-                encoding,
-                mode,
-                flag
-            });
-        }
-        return new Promise((resolve, reject) => {
-            fs_1.default.appendFile(src, data, {
-                encoding,
-                mode,
-                flag
-            }, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
-    }
-    readdir(dir, { sync = false, resolve = true, encoding = 'utf8' } = {}) {
-        if (resolve) {
-            dir = this.resolve(dir);
-        }
-        if (sync) {
-            return fs_1.default.readdirSync(dir, {
-                encoding
-            });
-        }
-        return new Promise((resolve, reject) => {
-            fs_1.default.readdir(dir, { encoding }, (err, list) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve(list);
-            });
-        });
-    }
-    mkdir(dir, { umask = 0o000, resolve = true, sync = false } = {}) {
-        if (resolve) {
-            dir = this.resolve(dir);
-        }
-        if (sync) {
-            return recurse_io_sync_1.default.mkdir(dir, umask);
-        }
-        return new Promise((resolve, reject) => {
-            recurse_io_1.default.mkdir(dir, umask, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
-    }
-    resolve(src) {
-        return path_1.default.resolve(this.pwd, src);
-    }
-    static bitmask(mode) {
-        let umask = 0o000;
-        if (mode & 256) {
-            umask += 0o400;
-        }
-        if (mode & 128) {
-            umask += 0o200;
-        }
-        if (mode & 64) {
-            umask += 0o100;
-        }
-        if (mode & 32) {
-            umask += 0o040;
-        }
-        if (mode & 16) {
-            umask += 0o020;
-        }
-        if (mode & 8) {
-            umask += 0o010;
-        }
-        if (mode & 4) {
-            umask += 0o004;
-        }
-        if (mode & 2) {
-            umask += 0o002;
-        }
-        if (mode & 1) {
-            umask += 0o001;
-        }
-        return umask;
-    }
-}
-exports.default = PoweredFileSystem;
-module.exports = PoweredFileSystem;
+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

@@ -0,0 +1,156 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import fs from 'node:fs';
+export type Mode = keyof IConstants;
+export type Flag = Mode | 'a';
+export type Stats = fs.Stats;
+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;
+    static bitmask: typeof bitmask;
+    constructor(pwd?: string);
+    private resolve;
+    test(src: string, options: {
+        sync: true;
+        flag?: Mode;
+    }): boolean;
+    test(src: string, options?: {
+        sync?: false;
+        flag?: Mode;
+    }): Promise<boolean>;
+    stat(src: string, options: {
+        sync: true;
+    }): Stats;
+    stat(src: string, options?: {
+        sync?: false;
+    }): Promise<Stats>;
+    chmod(src: string, mode: number, options: {
+        sync: true;
+    }): void;
+    chmod(src: string, mode: number, options?: {
+        sync?: false;
+    }): Promise<void>;
+    chown(src: string, uid: number, gid: number, options: {
+        sync: true;
+    }): void;
+    chown(src: string, uid: number, gid: number, options?: {
+        sync?: false;
+    }): Promise<void>;
+    symlink(src: string, use: string, options: {
+        sync: true;
+    }): void;
+    symlink(src: string, use: string, options?: {
+        sync?: false;
+    }): Promise<void>;
+    copy(src: string, dir: string, options: {
+        sync: true;
+        umask?: number;
+    }): void;
+    copy(src: string, dir: string, options?: {
+        sync?: false;
+        umask?: number;
+    }): Promise<void>;
+    rename(src: string, use: string, options: {
+        sync: true;
+    }): void;
+    rename(src: string, use: string, options?: {
+        sync?: false;
+    }): Promise<void>;
+    remove(src: string, options: {
+        sync: true;
+    }): void;
+    remove(src: string, options?: {
+        sync?: false;
+    }): Promise<void>;
+    read(src: string, options: {
+        sync: true;
+        encoding?: BufferEncoding;
+        flag?: Flag;
+    }): string;
+    read(src: string, options: {
+        sync: true;
+        encoding?: null;
+        flag?: Flag;
+    }): Buffer;
+    read(src: string, options: {
+        sync?: false;
+        encoding: null;
+        flag?: Flag;
+    }): Promise<Buffer>;
+    read(src: string, options?: {
+        sync?: false;
+        encoding?: BufferEncoding;
+        flag?: Flag;
+    }): Promise<string>;
+    write(src: string, data: Buffer, options: {
+        sync: true;
+        encoding: null;
+        umask?: number;
+        flag?: Flag;
+    }): void;
+    write(src: string, data: string, options: {
+        sync: true;
+        encoding?: BufferEncoding;
+        umask?: number;
+        flag?: Flag;
+    }): void;
+    write(src: string, data: Buffer, options: {
+        sync?: false;
+        encoding: null;
+        umask?: number;
+        flag?: Flag;
+    }): Promise<void>;
+    write(src: string, data: string, options?: {
+        sync?: false;
+        encoding?: BufferEncoding;
+        umask?: number;
+        flag?: Flag;
+    }): Promise<void>;
+    append(src: string, data: Buffer, options: {
+        sync: true;
+        encoding: null;
+        umask?: number;
+        flag?: Flag;
+    }): void;
+    append(src: string, data: string, options: {
+        sync: true;
+        encoding?: BufferEncoding;
+        umask?: number;
+        flag?: Flag;
+    }): void;
+    append(src: string, data: Buffer, options: {
+        sync?: false;
+        encoding: null;
+        umask?: number;
+        flag?: Flag;
+    }): Promise<void>;
+    append(src: string, data: string, options?: {
+        sync?: false;
+        encoding?: BufferEncoding;
+        umask?: number;
+        flag?: Flag;
+    }): Promise<void>;
+    readdir(dir: string, options: {
+        sync: true;
+        encoding?: BufferEncoding | null;
+    }): string[];
+    readdir(dir: string, options?: {
+        sync?: false;
+        encoding?: BufferEncoding | null;
+    }): Promise<string[]>;
+    mkdir(dir: string, options: {
+        sync: true;
+        umask?: number;
+    }): void;
+    mkdir(dir: string, options?: {
+        sync?: false;
+        umask?: number;
+    }): Promise<void>;
+}