pwd-fs 2.4.2 → 3.1.3

package/src/recurse-io.ts

@@ -1,234 +1,239 @@
-import fs from 'fs';
-import path from 'path';
+import fs from 'node:fs';
+import path from 'node:path';
 
-type Files = Array<string>
+export type Files = Array<string>;
+export type NoParamCallback = fs.NoParamCallback;
 
-const {sep} = path;
+const { sep } = path;
 
-export default {
-  chmod(src: string, mode: number, callback: fs.NoParamCallback): void {
-    let reduce = 0;
-
-    fs.stat(src, (err, stat) => {
-      if (err) {
-        return callback(err);
-      }
-
-      if (stat.isDirectory()) {
-        fs.readdir(src, (err, list) => {
-          if (err) {
-            return callback(err);
-          }
+function chmod(src: string, mode: number, callback: NoParamCallback) {
+  let reduce = 0;
 
-          if (list.length === 0) {
-            return fs.chmod(src, mode, callback);
-          }
+  fs.stat(src, (err, stat) => {
+    if (err) {
+      return callback(err);
+    }
 
-          reduce += list.length;
+    if (stat.isDirectory()) {
+      fs.readdir(src, (err, list) => {
+        if (err) {
+          return callback(err);
+        }
 
-          for (const loc of list) {
-            this.chmod(`${src}${sep}${loc}`, mode, (err) => {
-              if (err) {
-                return callback(err);
-              }
+        if (list.length === 0) {
+          return fs.chmod(src, mode, callback);
+        }
 
-              if (--reduce === 0) {
-                fs.chmod(src, mode, callback);
-              }
-            });
-          }
-        });
-      }
-      else {
-        fs.chmod(src, mode, callback);
-      }
-    });
-  },
-
-  chown(src: string, uid: number, gid: number, callback: fs.NoParamCallback): void {
-    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);
-          }
+        reduce += list.length;
 
-          if (list.length === 0) {
-            return fs.chown(src, uid, gid, callback);
-          }
+        for (const loc of list) {
+          chmod(`${src}${sep}${loc}`, mode, (err) => {
+            if (err) {
+              return callback(err);
+            }
 
-          reduce += list.length;
+            if (--reduce === 0) {
+              fs.chmod(src, mode, callback);
+            }
+          });
+        }
+      });
+    }
+    else {
+      fs.chmod(src, mode, callback);
+    }
+  });
+}
 
-          for (const loc of list) {
-            this.chown(`${src}${sep}${loc}`, uid, gid, (err) => {
-              if (err) {
-                return callback(err);
-              }
+function chown(src: string, uid: number, gid: number, callback: NoParamCallback) {
+  let reduce = 0;
 
-              if (--reduce === 0) {
-                fs.chown(src, uid, gid, callback);
-              }
-            });
-          }
-        });
-      }
-      else {
-        fs.chown(src, uid, gid, callback);
-      }
-    });
-  },
-
-  copy(src: string, dir: string, umask: number, callback: fs.NoParamCallback): void {
-    let reduce = 0;
-
-    fs.stat(src, (err, stat) => {
-      if (err) {
-        return callback(err);
-      }
-
-      if (stat.isDirectory()) {
-        fs.readdir(src, (err, list) => {
-          if (err) {
-            return callback(err);
-          }
+  fs.stat(src, (err, stats) => {
+    if (err) {
+      return callback(err);
+    }
 
-          reduce += list.length;
+    if (stats.isDirectory()) {
+      fs.readdir(src, (err, list) => {
+        if (err) {
+          return callback(err);
+        }
 
-          const paths = src.split(sep);
-          const loc = paths[paths.length - 1];
-          const mode = 0o777 - umask;
+        if (list.length === 0) {
+          return fs.chown(src, uid, gid, callback);
+        }
 
-          dir = `${dir}${sep}${loc}`;
+        reduce += list.length;
 
-          fs.mkdir(dir, { mode }, (err) => {
+        for (const loc of list) {
+          chown(`${src}${sep}${loc}`, uid, gid, (err) => {
             if (err) {
               return callback(err);
             }
 
-            if (reduce === 0) {
-              return callback(null);
-            }
-
-            for (const loc of list) {
-              this.copy(`${src}${sep}${loc}`, dir, umask, (err) => {
-                if (err) {
-                  return callback(err);
-                }
-
-                if (--reduce === 0) {
-                  callback(null);
-                }
-              });
+            if (--reduce === 0) {
+              fs.chown(src, uid, gid, callback);
             }
           });
-        });
-      }
-      else {
-        const mode = 0o666 - umask;
-        const loc = path.basename(src);
-
-        const readStream = fs.createReadStream(src);
-        const writeStream = fs.createWriteStream(`${dir}${sep}${loc}`, {
-          mode
-        });
+        }
+      });
+    }
+    else {
+      fs.chown(src, uid, gid, callback);
+    }
+  });
+}
 
-        readStream.on('error', callback);
-        writeStream.on('error', callback);
+function copy(src: string, dir: string, umask: number, callback: NoParamCallback) {
+  let reduce = 0;
 
-        writeStream.on('close', () => {
-          callback(null);
-        });
+  fs.stat(src, (err, stat) => {
+    if (err) {
+      return callback(err);
+    }
 
-        readStream.pipe(writeStream);
-      }
-    });
-  },
+    if (stat.isDirectory()) {
+      fs.readdir(src, (err, list) => {
+        if (err) {
+          return callback(err);
+        }
 
-  remove(src: string, callback: fs.NoParamCallback): void {
-    let reduce = 0;
+        reduce += list.length;
 
-    fs.stat(src, (err, stat) => {
-      if (err) {
-        return callback(err);
-      }
+        const paths = src.split(sep);
+        const loc = paths[paths.length - 1];
+        const mode = 0o777 - umask;
 
-      if (stat.isDirectory()) {
-        fs.readdir(src, (err, list) => {
+        dir = `${dir}${sep}${loc}`;
+
+        fs.mkdir(dir, { mode }, (err) => {
           if (err) {
             return callback(err);
           }
 
-          if (list.length === 0) {
-            return fs.rmdir(src, callback);
+          if (reduce === 0) {
+            return callback(null);
           }
 
-          reduce += list.length;
-
           for (const loc of list) {
-            this.remove(`${src}${sep}${loc}`, (err) => {
+            copy(`${src}${sep}${loc}`, dir, umask, (err) => {
               if (err) {
                 return callback(err);
               }
 
               if (--reduce === 0) {
-                fs.rmdir(src, callback);
+                callback(null);
               }
             });
           }
         });
-      }
-      else {
-        fs.unlink(src, callback);
-      }
-    });
-  },
-
-  mkdir(dir: string, umask: number, callback: fs.NoParamCallback): void {
-    const cwd = process.cwd();
-
-    if (dir === cwd) {
-      return callback(null);
+      });
     }
+    else {
+      const mode = 0o666 - umask;
+      const loc = path.basename(src);
 
-    const sequence = function* (dir: string, files: Files, mode: number): Generator<void, void, Generator> {
-      const iter = yield;
+      const readStream = fs.createReadStream(src);
+      const writeStream = fs.createWriteStream(`${dir}${sep}${loc}`, {
+        mode
+      });
 
-      for (const item of files) {
-        dir += `${sep}${item}`;
+      readStream.on('error', callback);
+      writeStream.on('error', callback);
 
-        fs.mkdir(dir, { mode }, (err) => {
-          if (err && err.errno !== -17) {
-            return callback(err);
-          }
+      writeStream.on('close', () => {
+        callback(null);
+      });
 
-          iter.next();
-        });
+      readStream.pipe(writeStream);
+    }
+  });
+}
+
+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);
+        }
+        
+        let reduce = list.length;
 
-        yield;
-      }
+        if (reduce === 0) {
+          return fs.rmdir(src, callback);
+        }
 
-      callback(null);
-    };
+        for (const loc of list) {
+          remove(`${src}${sep}${loc}`, (err) => {
+            if (err) {
+              return callback(err);
+            }
 
-    let use = '';
+            if (--reduce === 0) {
+              fs.rmdir(src, callback);
+            }
+          });
+        }
+      });
+    }
+    else {
+      fs.unlink(src, callback);
+    }
+  });
+}
+
+function mkdir(dir: string, umask: number, callback: NoParamCallback) {
+  const cwd = process.cwd();
+
+  if (dir === cwd) {
+    return callback(null);
+  }
 
-    if (dir.indexOf(cwd) === 0) {
-      use = cwd;
-      dir = dir.substr(cwd.length);
+  const sequence = function* (dir: string, files: Files, mode: number): Generator<void, void, Generator> {
+    const iter = yield;
+
+    for (const item of files) {
+      dir += `${sep}${item}`;
+
+      fs.mkdir(dir, { mode }, (err) => {
+        if (err && err.errno !== -17) {
+          return callback(err);
+        }
+
+        iter.next();
+      });
+
+      yield;
     }
 
-    const files = dir.split(sep);
-    const mode = 0o777 - umask;
+    callback(null);
+  };
 
-    const iter = sequence(use, files, mode);
+  let use = '';
 
-    iter.next();
-    iter.next(iter);
+  if (dir.indexOf(cwd) === 0) {
+    use = cwd;
+    dir = dir.substr(cwd.length);
   }
+
+  const files = dir.split(sep);
+  const mode = 0o777 - umask;
+
+  const iter = sequence(use, files, mode);
+
+  iter.next();
+  iter.next(iter);
+}
+
+export default {
+  chmod,
+  chown,
+  copy,
+  remove,
+  mkdir
 }

package/tsconfig.json

@@ -1,12 +1,19 @@
 {
-  "extends": "@tsconfig/node16/tsconfig.json",
   "compilerOptions": {
+    "lib": [
+			"es2022"
+		],
+		"module": "es2022",
+		"target": "es2022",
+		"moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
     "useUnknownInCatchVariables": false,
     "declaration": true,
-    "outDir": "./lib",
+    "outDir": "lib"
   },
-  "include": [
-    "src/**/*",
-    "**/*.spec.ts"
+  "exclude": [
+    "jest.config.ts"
   ]
 }