pwd-fs 3.3.0 → 3.3.5

package/src/powered-file-system.ts

@@ -1,369 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-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,
-  w: number,
-  x: number
-}
-
-export class PoweredFileSystem {
-  readonly pwd: string;
-
-  readonly constants: IConstants = {
-    e: fs.constants.F_OK,
-    r: fs.constants.R_OK,
-    w: fs.constants.W_OK,
-    x: fs.constants.X_OK
-  };
-
-  static bitmask = bitmask;
-
-  constructor(pwd?: string) {
-    this.pwd = pwd ? path.resolve(pwd) : process.cwd();
-  }
-  
-  private resolve(src: string) {
-    return path.resolve(this.pwd, src);
-  }
-
-  test<T extends boolean = false>(
-    src: string,
-    options?: {
-      sync?: T;
-      flag?: Mode;
-    }
-  ): T extends true ? boolean : Promise<boolean> {
-    const { sync = false as T, flag = 'e' } = options ?? {};
-    const mode = this.constants[flag];
-    src = path.resolve(this.pwd, src);
-
-    if (sync) {
-      return fs.existsSync(src) as any;
-    }
-
-    return new Promise<boolean>((resolve) => {
-      fs.access(src, mode, (err) => {
-        resolve(!err);
-      });
-    }) as any;
-  }
-
-  stat<T extends boolean = false>(
-    src: string,
-    options?: {
-      sync?: T;
-    }
-  ): T extends true ? Stats : Promise<Stats> {
-    const { sync = false as T } = options ?? {};
-    src = this.resolve(src);
-
-    if (sync) {
-      return fs.lstatSync(src) as any;
-    }
-
-    return new Promise<Stats>((resolve, reject) => {
-      fs.lstat(src, (err, stats) => {
-        if (err) {
-          return reject(err);
-        }
-
-        resolve(stats);
-      });
-    }) as any;
-  }
-
-  chmod<T extends boolean = false>(
-    src: string,
-    mode: number,
-    options?: { sync?: T }
-  ): T extends true ? void : Promise<void> {
-    const { sync = false as T } = options ?? {};
-    src = this.resolve(src);
-
-    if (sync) {
-      chmodSync(src, mode);
-      return undefined as any;
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      chmod(src, mode, (err) => {
-        if (err) {
-          return reject(err);
-        }
-
-        resolve();
-      });
-    }) as any;
-  }
-
-  chown<T extends boolean = false>(
-    src: string,
-    options?: { sync?: T; uid?: number; gid?: number }
-  ): T extends true ? void : Promise<void> {
-    const { sync = false as T, uid = 0, gid = 0 } = options ?? {};
-    src = this.resolve(src);
-
-    if (sync) {
-      chownSync(src, uid, gid);
-      return undefined as any;
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      chown(src, uid, gid, (err) => {
-        if (err) {
-          return reject(err);
-        }
-
-        resolve();
-      });
-    }) as any;
-  }
-
-  symlink<T extends boolean = false>(
-    src: string,
-    dest: string,
-    options?: { sync?: T }
-  ): T extends true ? void : Promise<void> {
-    src = this.resolve(src);
-    dest = this.resolve(dest);
-
-    const { sync = false as T } = options ?? {};
-
-    if (sync) {
-      fs.symlinkSync(src, dest);
-      return undefined as any;
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      fs.symlink(src, dest, (err) => {
-        if (err) {
-          return reject(err);
-        }
-
-        resolve();
-      });
-    }) as any;
-  }
-
-  copy<T extends boolean = false>(
-    src: string,
-    dest: string,
-    options?: { sync?: T; umask?: number }
-  ): T extends true ? void : Promise<void> {
-    src = this.resolve(src);
-    dest = this.resolve(dest);
-
-    const { sync = false as T, umask = 0o000 } = options ?? {};
-
-    if (sync) {
-      copySync(src, dest, umask);
-      return undefined as any;
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      copy(src, dest, umask, (err) => {
-        if (err) {
-          return reject(err);
-        }
-
-        resolve();
-      });
-    }) as any;
-  }
-
-  rename<T extends boolean = false>(
-    src: string,
-    dest: string,
-    options?: { sync?: T }
-  ): T extends true ? void : Promise<void> {
-    src = this.resolve(src);
-    dest = this.resolve(dest);
-
-    const { sync = false as T } = options ?? {};
-
-    if (sync) {
-      fs.renameSync(src, dest);
-      return undefined as any;
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      fs.rename(src, dest, (err) => {
-        if (err) {
-          return reject(err);
-        }
-
-        resolve();
-      });
-    }) as any;
-  }
-
-  remove<T extends boolean = false>(
-    src: string,
-    options?: { sync?: T }
-  ): T extends true ? void : Promise<void> {
-    src = this.resolve(src);
-    const { sync = false as T } = options ?? {};
-
-    if (sync) {
-      removeSync(src);
-      return undefined as any;
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      const callback: fs.NoParamCallback = (err) => {
-        if (err) {
-          return reject(err);
-        }
-
-        resolve();
-      };
-
-      if ('rm' in fs) {
-        fs.rm(src, { recursive: true }, callback);
-      }
-      else {
-        remove(src, callback);
-      }
-    }) as any;
-  }
-
-  read<T extends boolean = false>(
-    src: string,
-    options?: {
-      sync?: T;
-      encoding?: BufferEncoding | null;
-      flag?: Flag;
-    }
-  ): T extends true ? string | Buffer : Promise<string | Buffer> {
-    const { sync = false as T, encoding = 'utf8', flag = 'r' } = options ?? {};
-    const resolved = this.resolve(src);
-
-    if (sync) {
-      if (encoding === null) {
-        return fs.readFileSync(resolved, { encoding: null, flag }) as any;
-      }
-      else {
-        return fs.readFileSync(resolved, { encoding, flag }) as any;
-      }
-    }
-
-    return new Promise((resolve, reject) => {
-      fs.readFile(resolved, { encoding, flag }, (err, raw) => {
-        if (err) {
-          return reject(err);
-        }
-        
-        resolve(raw);
-      });
-    }) as any;
-  }
-
-  write<T extends boolean = false>(
-    src: string,
-    data: Buffer | string,
-    options?: {
-      sync?: T;
-      encoding?: BufferEncoding | null;
-      umask?: number;
-      flag?: Flag;
-    }
-  ): T extends true ? void : Promise<void> {
-    const {
-      sync = false as T,
-      encoding = 'utf8',
-      umask = 0o000,
-      flag = 'w',
-    } = options ?? {};
-    src = this.resolve(src);
-
-    const mode = 0o666 - umask;
-
-    if (sync) {
-      fs.writeFileSync(src, data, { encoding, mode, flag });
-      return undefined as any;
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      fs.writeFile(src, data, { encoding, mode, flag }, (err) => {
-        if (err) {
-          return reject(err);
-        }
-
-        resolve();
-      });
-    }) as any;
-  }
-
-  /**
-  * @deprecated The method should not be used
-  */
-  append<T extends boolean = false>(
-    src: string,
-    data: Buffer | string,
-    options?: {
-      sync?: T;
-      encoding?: BufferEncoding | null;
-      umask?: number;
-    }
-  ): T extends true ? void : Promise<void> {
-    const { sync = false as T, encoding = 'utf8', umask = 0o000 } = options ?? {};
-
-    return this.write(src, data, { sync, encoding, umask, flag: 'a' }) as any;
-  }
-
-  readdir<T extends boolean = false>(
-    dir: string,
-    options?: { sync?: T; encoding?: BufferEncoding | null }
-  ): T extends true ? string[] : Promise<string[]> {
-    const { sync = false as T, encoding = 'utf8' } = options ?? {};
-    dir = this.resolve(dir);
-
-    if (sync) {
-      return fs.readdirSync(dir, { encoding }) as any;
-    }
-
-    return new Promise<string[]>((resolve, reject) => {
-      fs.readdir(dir, { encoding }, (err, list) => {
-        if (err) {
-          return reject(err);
-        }
-
-        resolve(list);
-      });
-    }) as any;
-  }
-
-  mkdir<T extends boolean = false>(
-    dir: string,
-    options?: { sync?: T; umask?: number }
-  ): T extends true ? void : Promise<void> {
-    const { sync = false as T, umask = 0o000 } = options ?? {};
-    dir = this.resolve(dir);
-
-    if (sync) {
-      mkdirSync(dir, umask);
-      return undefined as any;
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      mkdir(dir, umask, (err) => {
-        if (err) {
-          return reject(err);
-        }
-
-        resolve();
-      });
-    }) as any;
-  }
-}

package/src/recurse-io-sync.ts

@@ -1,105 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-export function chmodSync(src: string, mode: number) {
-  const stats = fs.statSync(src);
-
-  if (stats.isDirectory()) {
-    const list = fs.readdirSync(src);
-
-    for (const loc of list) {
-      chmodSync(path.join(src, loc), mode);
-    }
-  }
-
-  fs.chmodSync(src, mode);
-}
-
-export function chownSync(src: string, uid: number, gid: number) {
-  const stats = fs.statSync(src);
-
-  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) {
-      chownSync(path.join(src, loc), uid, gid);
-    }
-  }
-
-  fs.chownSync(src, uid, gid);
-}
-
-export function copySync(src: string, dir: string, umask: number) {
-  const stat = fs.statSync(src);
-
-  if (stat.isDirectory()) {
-    const list = fs.readdirSync(src);
-
-    const loc = path.basename(src);
-    const mode = 0o777 - umask;
-
-    dir = path.join(dir, loc);
-    fs.mkdirSync(dir, mode);
-
-    for (const loc of list) {
-      copySync(path.join(src, loc), dir, umask);
-    }
-  }
-  else {
-    const loc = path.basename(src);
-    const use = path.join(dir, loc);
-
-    fs.copyFileSync(src, use);
-  }
-}
-
-export function removeSync(src: string) {
-  const stats = fs.statSync(src);
-
-  if (stats.isDirectory()) {
-    const list = fs.readdirSync(src);
-
-    for (const loc of list) {
-      removeSync(path.join(src, loc));
-    }
-
-    fs.rmdirSync(src);
-  }
-  else {
-    fs.unlinkSync(src);
-  }
-}
-
-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.substring(cwd.length);
-  }
-
-  const ways = dir.split(path.sep).slice(1);
-
-  for (const loc of ways) {
-    use = path.join(use, loc);
-
-    try {
-      fs.mkdirSync(use, { mode });
-    }
-    catch (err) {
-      if (err.code !== 'EEXIST') {
-        throw err;
-      }
-    }
-  }
-}

package/src/recurse-io.ts

@@ -1,221 +0,0 @@
-import fs, { NoParamCallback } from 'node:fs';
-import path from 'node:path';
-
-export function chmod(src: string, mode: number, callback: NoParamCallback) {
-  let reduce = 0;
-
-  fs.stat(src, (err, stats) => {
-    if (err) return callback(err);
-
-    if (stats.isDirectory()) {
-      fs.readdir(src, (err, list) => {
-        if (err) {
-          return callback(err);
-        }
-
-        if (list.length === 0) {
-          return fs.chmod(src, mode, callback);
-        }
-
-        reduce = list.length;
-
-        for (const loc of list) {
-          chmod(path.join(src, loc), mode, (err) => {
-            if (err) {
-              return callback(err);
-            }
-
-            if (--reduce === 0) {
-              fs.chmod(src, mode, callback);
-            }
-          });
-        }
-      });
-    }
-    else {
-      fs.chmod(src, mode, callback);
-    }
-  });
-}
-
-export function chown(src: string, uid: number, gid: number, callback: NoParamCallback) {
-  let reduce = 0;
-
-  fs.stat(src, (err, stats) => {
-    if (err) {
-      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) {
-          return callback(err);
-        }
-        
-        if (list.length === 0) {
-          return fs.chown(src, uid, gid, callback);
-        }
-
-        reduce = list.length;
-
-        for (const loc of list) {
-          chown(path.join(src, loc), uid, gid, (err) => {
-            if (err) {
-              return callback(err);
-            }
-
-            if (--reduce === 0) {
-              fs.chown(src, uid, gid, callback);
-            }
-          });
-        }
-      });
-    }
-    else {
-      fs.chown(src, uid, gid, callback);
-    }
-  });
-}
-
-export function copy(src: string, dir: string, umask: number, callback: NoParamCallback) {
-  fs.stat(src, (err, stat) => {
-    if (err) {
-      return callback(err);
-    }
-
-    if (stat.isDirectory()) {
-      fs.readdir(src, (err, list) => {
-        if (err) {
-          return callback(err);
-        }
-
-        const loc = path.basename(src);
-        const destDir = path.join(dir, loc);
-        const mode = 0o777 - umask;
-
-        fs.mkdir(destDir, { mode }, (err) => {
-          if (err) {
-            if (err.code === 'EEXIST') {
-              err = new Error(`Target already exists: ${destDir}`);
-            }
-
-            return callback(err);
-          }
-
-          if (list.length === 0) {
-            return callback(null);
-          }
-
-          let reduce = list.length;
-
-          for (const item of list) {
-            copy(path.join(src, item), destDir, umask, (err) => {
-              if (err) {
-                return callback(err);
-              }
-
-              if (--reduce === 0) {
-                callback(null);
-              }
-            });
-          }
-        });
-      });
-    }
-    else {
-      const loc = path.basename(src);
-      const dest = path.join(dir, loc);
-      const mode = 0o666 - umask;
-
-      const readStream = fs.createReadStream(src);
-      const writeStream = fs.createWriteStream(dest, { mode });
-
-      readStream.on('error', callback);
-      writeStream.on('error', callback);
-      writeStream.on('close', () => callback(null));
-
-      readStream.pipe(writeStream);
-    }
-  });
-}
-
-export function remove(src: string, callback: NoParamCallback) {
-  fs.stat(src, (err, stat) => {
-    if (err) {
-      return callback(err);
-    }
-
-    if (stat.isDirectory()) {
-      fs.readdir(src, (err, list) => {
-        if (err) {
-          return callback(err);
-        }
-
-        if (list.length === 0) {
-          return fs.rmdir(src, callback);
-        }
-
-        let reduce = list.length;
-
-        for (const loc of list) {
-          remove(path.join(src, loc), (err) => {
-            if (err) {
-              return callback(err);
-            }
-
-            if (--reduce === 0) {
-              fs.rmdir(src, callback);
-            }
-          });
-        }
-      });
-    }
-    else {
-      fs.unlink(src, callback);
-    }
-  });
-}
-
-export function mkdir(dir: string, umask: number, callback: NoParamCallback) {
-  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(path.sep).filter(Boolean);
-
-  function next(index: number) {
-    if (index >= parts.length) {
-      return callback(null);
-    }
-
-    base = path.join(base, parts[index]);
-
-    fs.mkdir(base, { mode }, (err) => {
-      if (err && err.code !== 'EEXIST') {
-        return callback(err);
-      }
-
-      next(index + 1);
-    });
-  }
-
-  next(0);
-}