@wocker/ws 1.0.2 → 1.0.4

package/lib/makes/FS.d.ts

@@ -1,13 +1,13 @@
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="node" />
+import { FS as CoreFS } from "@wocker/core";
 import * as fs from "fs";
-import { Stats, BigIntStats, PathLike, PathOrFileDescriptor, WriteFileOptions, MakeDirectoryOptions, RmOptions } from "fs";
+import { Stats, BigIntStats, PathLike, PathOrFileDescriptor, WriteFileOptions, MakeDirectoryOptions } from "fs";
 import { PassThrough } from "readable-stream";
 type ReaddirFilesOptions = {
     recursive?: boolean;
 };
-declare class FS {
+declare class FS extends CoreFS {
     static access(path: PathLike): Promise<any>;
     static exists(path: PathLike): Promise<boolean>;
     static existsSync(path: PathLike): boolean;
@@ -17,21 +17,15 @@ declare class FS {
     static readdirFiles(path: string, options?: ReaddirFilesOptions): Promise<string[]>;
     static appendFile(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): Promise<unknown>;
     static appendFileSync(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): void;
-    static read(): void;
     static readBytes(filePath: PathLike, position?: number | bigint, size?: number | bigint): Promise<Buffer>;
-    static readFile(filePath: PathLike | number): Promise<Buffer>;
     static readFileSync(filePath: PathLike): Buffer;
-    static writeFile(filePath: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): Promise<void>;
     static writeFileSync(path: PathLike, data: any, options?: WriteFileOptions): void;
     static createWriteStream(path: PathLike): fs.WriteStream;
-    static readJSON(...paths: string[]): Promise<any>;
-    static writeJSON(filePath: PathLike | number, data: any): Promise<void>;
     static unlink(filePath: PathLike): Promise<void>;
     static watch(filename: PathLike, options?: any): fs.FSWatcher;
     static stat(filename: PathLike, options?: Parameters<typeof fs.stat>[1]): Promise<Stats | BigIntStats>;
     static createReadStream(path: PathLike, options?: Parameters<typeof fs.createReadStream>[1]): fs.ReadStream;
     static createReadLinesStream(path: PathLike, count?: number): PassThrough;
     static copyFile(src: PathLike, dest: PathLike): Promise<void>;
-    static rm(path: PathLike, options?: RmOptions): Promise<unknown>;
 }
 export { FS };

package/lib/makes/FS.js

@@ -1,320 +1,292 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
 });
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.FS = void 0;
-var fs = _interopRequireWildcard(require("fs"));
-var Path = _interopRequireWildcard(require("path"));
-var _readableStream = require("readable-stream");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-class FS {
-  static async access(path) {
-    return new Promise((resolve, reject) => {
-      fs.access(path, err => {
-        if (!err) {
-          resolve(null);
-        } else {
-          reject(err);
-        }
-      });
-    });
-  }
-
-  /**
-   * Asynchronously tests whether or not the given path exists by checking with the file system.
-   * @param path path A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
-   */
-  static async exists(path) {
-    return new Promise(resolve => {
-      fs.exists(path, exists => {
-        resolve(exists);
-      });
-    });
-  }
-  static existsSync(path) {
-    return fs.existsSync(path);
-  }
-  static async mkdir(dirPath, options = {}) {
-    return new Promise((resolve, reject) => {
-      fs.mkdir(dirPath, options, err => {
-        if (!err) {
-          resolve();
-        } else {
-          reject(err);
-        }
-      });
-    });
-  }
-  static mkdirSync(path, options) {
-    return fs.mkdirSync(path, options);
-  }
-  static async readdir(path) {
-    return new Promise((resolve, reject) => {
-      fs.readdir(path, (err, files) => {
-        if (!err) {
-          resolve(files);
-        } else {
-          reject(err);
-        }
-      });
-    });
-  }
-  static async readdirFiles(path, options) {
-    const {
-      recursive = false
-    } = options || {};
-    if (recursive) {
-      const names = await FS.readdir(path);
-      let res = [];
-      for (const name of names) {
-        const filePath = Path.join(path, name);
-        let sub = [name];
-        const stats = await FS.stat(filePath);
-        if (stats.isDirectory()) {
-          sub = (await FS.readdirFiles(filePath, {
-            recursive: true
-          })).map(subName => {
-            return Path.join(name, subName);
-          });
-        }
-        res = [...res, ...sub];
-      }
-      return res;
+const core_1 = require("@wocker/core");
+const fs = __importStar(require("fs"));
+const Path = __importStar(require("path"));
+const readable_stream_1 = require("readable-stream");
+class FS extends core_1.FS {
+    static async access(path) {
+        return new Promise((resolve, reject) => {
+            fs.access(path, (err) => {
+                if (!err) {
+                    resolve(null);
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
     }
-    return new Promise((resolve, reject) => {
-      fs.readdir(path, {
-        withFileTypes: true
-      }, (err, files) => {
-        if (err) {
-          return reject(err);
-        }
-        const names = files.filter(dirent => {
-          return dirent.isFile();
-        }).map(dirent => {
-          return dirent.name;
+    static async exists(path) {
+        return new Promise((resolve) => {
+            fs.exists(path, (exists) => {
+                resolve(exists);
+            });
         });
-        resolve(names);
-      });
-    });
-  }
-  static async appendFile(path, data, options) {
-    return new Promise((resolve, reject) => {
-      fs.appendFile(path, data, options, (error, data) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(data);
-        }
-      });
-    });
-  }
-  static appendFileSync(path, data, options) {
-    return fs.appendFileSync(path, data, options);
-  }
-  static read() {
-    //
-  }
-  static async readBytes(filePath, position = 0, size) {
-    if (position < 0 && typeof size === "undefined") {
-      const stats = await FS.stat(filePath);
-      size = BigInt(position) * -1n;
-      position = BigInt(stats.size) - size;
-      if (position < 0n) {
-        position = 0;
-      }
-    } else if (typeof size === "undefined") {
-      const stats = await FS.stat(filePath);
-      if (typeof stats.size !== "bigint" && typeof position !== "bigint") {
-        size = stats.size - position;
-      } else {
-        size = BigInt(stats.size) - BigInt(position);
-      }
     }
-    if (size < 0n) {
-      // throw Error(`Buffer size ${size}`);
-
-      return Buffer.alloc(0);
+    static existsSync(path) {
+        return fs.existsSync(path);
     }
-    const buffer = Buffer.alloc(Number(size));
-    return new Promise((resolve, reject) => {
-      fs.open(filePath, (err, file) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        fs.read(file, buffer, 0, buffer.length, position, (err, bytesRead, buffer) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-          resolve(buffer);
+    static async mkdir(dirPath, options = {}) {
+        return new Promise((resolve, reject) => {
+            fs.mkdir(dirPath, options, (err) => {
+                if (!err) {
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
         });
-      });
-    });
-  }
-  static async readFile(filePath) {
-    return new Promise((resolve, reject) => {
-      fs.readFile(filePath, (err, data) => {
-        if (!err) {
-          resolve(data);
-        } else {
-          reject(err);
-        }
-      });
-    });
-  }
-  static readFileSync(filePath) {
-    return fs.readFileSync(filePath);
-  }
-  static async writeFile(filePath, data, options) {
-    return new Promise((resolve, reject) => {
-      fs.writeFile(filePath, data, options, err => {
-        if (!err) {
-          resolve();
-        } else {
-          reject(err);
-        }
-      });
-    });
-  }
-  static writeFileSync(path, data, options) {
-    return fs.writeFileSync(path, data, options);
-  }
-  static createWriteStream(path) {
-    return fs.createWriteStream(path);
-  }
-  static async readJSON(...paths) {
-    const res = await new Promise((resolve, reject) => {
-      const filePath = Path.join(...paths);
-      fs.readFile(filePath, (err, data) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve(data);
-      });
-    });
-    return JSON.parse(res.toString());
-  }
-  static async writeJSON(filePath, data) {
-    const json = JSON.stringify(data, null, 4);
-    return FS.writeFile(filePath, json);
-  }
-  static async unlink(filePath) {
-    return new Promise((resolve, reject) => {
-      fs.unlink(filePath, err => {
-        if (!err) {
-          resolve();
-        } else {
-          reject(err);
-        }
-      });
-    });
-  }
-  static watch(filename, options) {
-    return fs.watch(filename, options);
-  }
-  static stat(filename, options) {
-    return new Promise((resolve, reject) => {
-      fs.stat(filename, options, (err, stats) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(stats);
-        }
-      });
-    });
-  }
-  static createReadStream(path, options) {
-    return fs.createReadStream(path, options);
-  }
-  static createReadLinesStream(path, count) {
-    const write = new _readableStream.PassThrough();
-    (async () => {
-      if (typeof count === "undefined" || count > 0) {
-        const stats = await FS.stat(path);
-        const resLines = [""];
-        let position = 0n;
-        while (position < stats.size) {
-          let size = BigInt(count ? 64 * count : 255);
-          if (position + size > stats.size) {
-            size = BigInt(stats.size) - position;
-          }
-          const buffer = await FS.readBytes(path, position, size);
-          const lines = buffer.toString("utf-8").split("\n");
-          position += size;
-          for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            if (i === 0) {
-              resLines[resLines.length - 1] = (resLines[resLines.length - 1] || "") + line;
-            } else {
-              resLines.push(line);
+    }
+    static mkdirSync(path, options) {
+        return fs.mkdirSync(path, options);
+    }
+    static async readdir(path) {
+        return new Promise((resolve, reject) => {
+            fs.readdir(path, (err, files) => {
+                if (!err) {
+                    resolve(files);
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    static async readdirFiles(path, options) {
+        const { recursive = false } = options || {};
+        if (recursive) {
+            const names = await FS.readdir(path);
+            let res = [];
+            for (const name of names) {
+                const filePath = Path.join(path, name);
+                let sub = [
+                    name
+                ];
+                const stats = await FS.stat(filePath);
+                if (stats.isDirectory()) {
+                    sub = (await FS.readdirFiles(filePath, { recursive: true })).map((subName) => {
+                        return Path.join(name, subName);
+                    });
+                }
+                res = [
+                    ...res,
+                    ...sub
+                ];
             }
-          }
-          if (resLines.length > count + 1) {
-            break;
-          }
-        }
-        for (let i = 0; i < (count || resLines.length); i++) {
-          write.write(resLines[i]);
+            return res;
         }
-      } else if (count < 0) {
-        const stats = await FS.stat(path);
-        const resLines = [""];
-        let position = BigInt(stats.size);
-        while (position > 0n) {
-          // let size = BigInt(64 * count * -1);
-          let size = BigInt(2 * count * -1);
-          position -= size;
-          if (position < 0) {
-            size = position + size;
-            position = 0n;
-          }
-          const buffer = await FS.readBytes(path, position, size);
-          const lines = buffer.toString("utf-8").split("\n").reverse();
-          for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            if (i === 0) {
-              resLines[0] = line + (resLines[0] || "");
-            } else {
-              resLines.unshift(line);
+        return new Promise((resolve, reject) => {
+            fs.readdir(path, {
+                withFileTypes: true
+            }, (err, files) => {
+                if (err) {
+                    return reject(err);
+                }
+                const names = files.filter((dirent) => {
+                    return dirent.isFile();
+                }).map((dirent) => {
+                    return dirent.name;
+                });
+                resolve(names);
+            });
+        });
+    }
+    static async appendFile(path, data, options) {
+        return new Promise((resolve, reject) => {
+            fs.appendFile(path, data, options, (error, data) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(data);
+                }
+            });
+        });
+    }
+    static appendFileSync(path, data, options) {
+        return fs.appendFileSync(path, data, options);
+    }
+    static async readBytes(filePath, position = 0, size) {
+        if (position < 0 && typeof size === "undefined") {
+            const stats = await FS.stat(filePath);
+            size = BigInt(position) * -1n;
+            position = BigInt(stats.size) - size;
+            if (position < 0n) {
+                position = 0;
             }
-          }
-          if (resLines.length > count * -1 + 1) {
-            break;
-          }
-        }
-        const lines = resLines.slice(count - 1);
-        for (let i = 0; i < lines.length; i++) {
-          write.write(lines[i]);
         }
-        write.end();
-      }
-    })();
-    return write;
-  }
-  static async copyFile(src, dest) {
-    new Promise((resolve, reject) => {
-      fs.copyFile(src, dest, err => {
-        if (!err) {
-          resolve(undefined);
-        } else {
-          reject(err);
+        else if (typeof size === "undefined") {
+            const stats = await FS.stat(filePath);
+            if (typeof stats.size !== "bigint" && typeof position !== "bigint") {
+                size = stats.size - position;
+            }
+            else {
+                size = BigInt(stats.size) - BigInt(position);
+            }
         }
-      });
-    });
-  }
-  static async rm(path, options) {
-    return new Promise((resolve, reject) => {
-      fs.rm(path, options, err => {
-        if (err) {
-          return reject(err);
+        if (size < 0n) {
+            return Buffer.alloc(0);
         }
-        return resolve(undefined);
-      });
-    });
-  }
+        const buffer = Buffer.alloc(Number(size));
+        return new Promise((resolve, reject) => {
+            fs.open(filePath, (err, file) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                fs.read(file, buffer, 0, buffer.length, position, (err, bytesRead, buffer) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(buffer);
+                });
+            });
+        });
+    }
+    static readFileSync(filePath) {
+        return fs.readFileSync(filePath);
+    }
+    static writeFileSync(path, data, options) {
+        return fs.writeFileSync(path, data, options);
+    }
+    static createWriteStream(path) {
+        return fs.createWriteStream(path);
+    }
+    static async unlink(filePath) {
+        return new Promise((resolve, reject) => {
+            fs.unlink(filePath, (err) => {
+                if (!err) {
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    static watch(filename, options) {
+        return fs.watch(filename, options);
+    }
+    static stat(filename, options) {
+        return new Promise((resolve, reject) => {
+            fs.stat(filename, options, (err, stats) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(stats);
+                }
+            });
+        });
+    }
+    static createReadStream(path, options) {
+        return fs.createReadStream(path, options);
+    }
+    static createReadLinesStream(path, count) {
+        const write = new readable_stream_1.PassThrough();
+        (async () => {
+            if (typeof count === "undefined" || count > 0) {
+                const stats = await FS.stat(path);
+                const resLines = [""];
+                let position = 0n;
+                while (position < stats.size) {
+                    let size = BigInt(count ? 64 * count : 255);
+                    if (position + size > stats.size) {
+                        size = BigInt(stats.size) - position;
+                    }
+                    const buffer = await FS.readBytes(path, position, size);
+                    const lines = buffer.toString("utf-8").split("\n");
+                    position += size;
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i];
+                        if (i === 0) {
+                            resLines[resLines.length - 1] = (resLines[resLines.length - 1] || "") + line;
+                        }
+                        else {
+                            resLines.push(line);
+                        }
+                    }
+                    if (resLines.length > count + 1) {
+                        break;
+                    }
+                }
+                for (let i = 0; i < (count || resLines.length); i++) {
+                    write.write(resLines[i]);
+                }
+            }
+            else if (count < 0) {
+                const stats = await FS.stat(path);
+                const resLines = [""];
+                let position = BigInt(stats.size);
+                while (position > 0n) {
+                    let size = BigInt(2 * count * -1);
+                    position -= size;
+                    if (position < 0) {
+                        size = position + size;
+                        position = 0n;
+                    }
+                    const buffer = await FS.readBytes(path, position, size);
+                    const lines = buffer.toString("utf-8").split("\n").reverse();
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i];
+                        if (i === 0) {
+                            resLines[0] = line + (resLines[0] || "");
+                        }
+                        else {
+                            resLines.unshift(line);
+                        }
+                    }
+                    if (resLines.length > count * -1 + 1) {
+                        break;
+                    }
+                }
+                const lines = resLines.slice(count - 1);
+                for (let i = 0; i < lines.length; i++) {
+                    write.write(lines[i]);
+                }
+                write.end();
+            }
+        })();
+        return write;
+    }
+    static async copyFile(src, dest) {
+        new Promise((resolve, reject) => {
+            fs.copyFile(src, dest, (err) => {
+                if (!err) {
+                    resolve(undefined);
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
 }
-exports.FS = FS;
+exports.FS = FS;