iobroker.javascript 9.0.1 → 9.0.3

package/build-backend/lib/protectFs.js

@@ -198,13 +198,16 @@ class ProtectFs {
             throw new Error('Permission denied');
         }
     }
-    access(path, callback) {
+    access(path, mode, callback) {
         this.#checkProtected(path, true);
-        return nodeFS.access(path, callback);
+        if (typeof callback === 'function') {
+            return nodeFS.access(path, mode, callback);
+        }
+        return nodeFS.access(path, mode);
     }
     accessSync(path, mode) {
         this.#checkProtected(path, true);
-        return nodeFS.accessSync(path, mode); // function accessSync(path, mode) {
+        return nodeFS.accessSync(path, mode);
     }
     cp(source, destination, opts, callback) {
         this.#checkProtected(source, false);
@@ -220,27 +223,36 @@ class ProtectFs {
     cpSync(source, destination, opts) {
         this.#checkProtected(source, false);
         this.#checkProtected(destination, false);
-        return nodeFS.cpSync.call(this, source, destination, opts); // function cpSync(src, dest, options) {
+        return nodeFS.cpSync.call(this, source, destination, opts);
     }
-    readFile(path, callback) {
+    readFile(path, options, callback) {
         if (typeof path !== 'number') {
             this.#checkProtected(path, true);
         }
-        return nodeFS.readFile.call(this, path, callback); // function readFile(path, options, callback) {
+        if (typeof callback === 'function') {
+            return nodeFS.readFile.call(this, path, options, 
+            // @ts-expect-error readFile can accept 3 arguments too
+            callback);
+        }
+        return nodeFS.readFile.call(this, path, options);
     }
     readFileSync(path, options) {
         if (typeof path !== 'number') {
             this.#checkProtected(path, true);
         }
-        return nodeFS.readFileSync.call(this, path, options); // function readFileSync(path, options) {
+        return nodeFS.readFileSync.call(this, path, options);
     }
-    readlink(path, callback) {
+    readlink(path, options, callback) {
         this.#checkProtected(path, true);
-        return nodeFS.readlink.call(this, path, callback); // function readlink(path, options, callback) {
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.readlink.call(this, path, options, callback); //
+        }
+        return nodeFS.readlink.call(this, path, options);
     }
     readlinkSync(path, options) {
         this.#checkProtected(path, true);
-        return nodeFS.readlinkSync.call(this, path, options); // function readlinkSync(path, options) {
+        return nodeFS.readlinkSync.call(this, path, options);
     }
     symlink(target, path, type, callback) {
         this.#checkProtected(target, true);
@@ -249,228 +261,266 @@ class ProtectFs {
             // @ts-expect-error should work
             return nodeFS.symlink.call(this, target, path, type, callback);
         }
-        return nodeFS.symlink.call(this, target, path, type); // function symlink(target, path, type_, callback_) {
+        return nodeFS.symlink.call(this, target, path, type);
     }
     symlinkSync(target, path, type) {
         this.#checkProtected(target, true);
         this.#checkProtected(path, false);
-        return nodeFS.symlinkSync.call(this, target, path, type); // function symlinkSync(target, path, type) {
+        return nodeFS.symlinkSync.call(this, target, path, type);
     }
     writeFile(file, data, options, callback) {
         if (typeof file !== 'number') {
             this.#checkProtected(file, false);
         }
-        // @ts-expect-error should work
-        return nodeFS.writeFile.call(this, file, data, options, callback); // function writeFile(path, data, options, callback) {
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.writeFile.call(this, file, data, options, callback);
+        }
+        return nodeFS.writeFile.call(this, file, data, options);
     }
     writeFileSync(file, data, options) {
         if (typeof file !== 'number') {
             this.#checkProtected(file, false);
         }
-        return nodeFS.writeFileSync.call(this, file, data, options); // function writeFileSync(path, data, options) {
+        return nodeFS.writeFileSync.call(this, file, data, options);
     }
     unlink(path, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.unlink.call(this, path, callback); // function unlink(path, callback) {
+        return nodeFS.unlink.call(this, path, callback || ((_err) => { }));
     }
     unlinkSync(path) {
         this.#checkProtected(path, false);
-        return nodeFS.unlinkSync.call(this, path); // function unlinkSync(path) {
+        return nodeFS.unlinkSync.call(this, path);
     }
-    appendFile(file, data, callback) {
+    appendFile(file, data, options, callback) {
         if (typeof file !== 'number') {
             this.#checkProtected(file, false);
         }
-        return nodeFS.appendFile.call(this, file, data, callback); // function appendFile(path, data, options, callback) {
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.appendFile.call(this, file, data, options, callback);
+        }
+        return nodeFS.appendFile.call(this, file, data, options);
     }
-    appendFileSync(file, data) {
+    appendFileSync(file, data, options) {
         if (typeof file !== 'number') {
             this.#checkProtected(file, false);
         }
-        return nodeFS.appendFileSync.call(this, file, data); // function appendFileSync(path, data, options) {
+        return nodeFS.appendFileSync.call(this, file, data, options);
     }
     chmod(path, mode, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.chmod.call(this, path, mode, callback); // function chmod(path, mode, callback) {
+        return nodeFS.chmod.call(this, path, mode, callback || ((_err) => { }));
     }
     chmodSync(path, mode) {
         this.#checkProtected(path, false);
-        return nodeFS.chmodSync.call(this, path, mode); // function chmodSync(path, mode) {
+        return nodeFS.chmodSync.call(this, path, mode);
     }
     chown(path, uid, gid, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.chown.call(this, path, uid, gid, callback); // function chown(path, uid, gid, callback) {
+        return nodeFS.chown.call(this, path, uid, gid, callback || ((_err) => { }));
     }
     chownSync(path, uid, gid) {
         this.#checkProtected(path, false);
-        return nodeFS.chownSync.call(this, path, uid, gid); // function chownSync(path, uid, gid) {
+        return nodeFS.chownSync.call(this, path, uid, gid);
     }
     copyFile(src, dest, mode, callback) {
         this.#checkProtected(src, true);
         this.#checkProtected(dest, false);
         // @ts-expect-error should work
-        return nodeFS.copyFile.call(this, src, dest, mode, callback); // function copyFile(src, dest, mode, callback) {
+        return nodeFS.copyFile.call(this, src, dest, mode, callback);
     }
     copyFileSync(src, dest, mode) {
         this.#checkProtected(src, true);
         this.#checkProtected(dest, false);
-        return nodeFS.copyFileSync.call(this, src, dest, mode); // function copyFileSync(src, dest, mode) {
+        return nodeFS.copyFileSync.call(this, src, dest, mode);
     }
     rename(oldPath, newPath, callback) {
         this.#checkProtected(oldPath, false);
         this.#checkProtected(newPath, false);
-        return nodeFS.rename.call(this, oldPath, newPath, callback); // function rename(oldPath, newPath, callback) {
+        return nodeFS.rename.call(this, oldPath, newPath, callback || ((_err) => { }));
     }
     renameSync(oldPath, newPath) {
         this.#checkProtected(oldPath, false);
         this.#checkProtected(newPath, false);
-        return nodeFS.renameSync.call(this, oldPath, newPath); // function renameSync(oldPath, newPath) {
+        return nodeFS.renameSync.call(this, oldPath, newPath);
     }
     open(path, callback) {
         this.#checkProtected(path, true);
-        return nodeFS.open.call(this, path, callback); // function open(path, flags, mode, callback) {
+        return nodeFS.open.call(this, path, callback);
     }
     openSync(path, flags, mode) {
         this.#checkProtected(path, true);
-        return nodeFS.openSync.call(this, path, flags, mode); // function openSync(path, flags, mode) {
+        return nodeFS.openSync.call(this, path, flags, mode);
     }
     truncate(path, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.truncate.call(this, path, callback); // function truncate(path, len, callback) {
+        return nodeFS.truncate.call(this, path, callback || ((_err) => { }));
     }
     truncateSync(path) {
         this.#checkProtected(path, false);
-        return nodeFS.truncateSync.call(this, path); // function truncateSync(path, len) {
+        return nodeFS.truncateSync.call(this, path);
     }
     exists(path, callback) {
         this.#checkProtected(path, true);
-        return nodeFS.exists.call(this, path, callback); // function exists(path, callback) {
+        return nodeFS.exists.call(this, path, callback);
     }
     existsSync(path) {
         this.#checkProtected(path, true);
-        return nodeFS.existsSync.call(this, path); // function existsSync(path) {
+        return nodeFS.existsSync.call(this, path);
     }
     stat(path, options, callback) {
         this.#checkProtected(path, true);
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.stat.call(this, path, options, callback);
+        }
         // @ts-expect-error should work
-        return nodeFS.stat.call(this, path, options, callback); // function stat(path, options = { bigint: false }, callback) {
+        return nodeFS.stat.call(this, path, options);
     }
     statSync(path, options) {
         this.#checkProtected(path, true);
-        return nodeFS.statSync.call(this, path, options); // function statSync(path, options = { bigint: false, throwIfNoEntry: true }) {
+        return nodeFS.statSync.call(this, path, options);
     }
     utimes(path, atime, mtime, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.utimes.call(this, path, atime, mtime, callback); // function utimes(path, atime, mtime, callback) {
+        return nodeFS.utimes.call(this, path, atime, mtime, callback || ((_err) => { }));
     }
     utimesSync(path, atime, mtime) {
         this.#checkProtected(path, false);
-        return nodeFS.utimesSync.call(this, path, atime, mtime); // function utimesSync(path, atime, mtime) {
+        return nodeFS.utimesSync.call(this, path, atime, mtime);
     }
     readdir(path, options, callback) {
         this.#checkProtected(path, true);
+        if (typeof callback === 'function') {
+            return nodeFS.readdir.call(this, path, options, callback);
+        }
         // @ts-expect-error should work
-        return nodeFS.readdir.call(this, path, options, callback); // function readdir(path, options, callback) {
+        return nodeFS.readdir.call(this, path, options);
     }
     readdirSync(path, options) {
         this.#checkProtected(path, true);
         // @ts-expect-error should work
-        return nodeFS.readdirSync.call(this, path, options); // function readdirSync(path, options) {
+        return nodeFS.readdirSync.call(this, path, options);
     }
     createReadStream(path, options) {
         this.#checkProtected(path, true);
-        return nodeFS.createReadStream.call(this, path, options); // function createReadStream(path, options) {
+        return nodeFS.createReadStream.call(this, path, options);
     }
     createWriteStream(path, options) {
         this.#checkProtected(path, false);
-        return nodeFS.createWriteStream.call(this, path, options); // function createWriteStream(path, options) {
+        return nodeFS.createWriteStream.call(this, path, options);
     }
     lchmod(path, mode, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.lchmod.call(this, path, mode, callback); // function lchmod(path, mode, callback) {
+        return nodeFS.lchmod.call(this, path, mode, callback || ((_err) => { }));
     }
     lchmodSync(path, mode) {
         this.#checkProtected(path, false);
-        return nodeFS.lchmodSync.call(this, path, mode); // function lchmodSync(path, mode) {
+        return nodeFS.lchmodSync.call(this, path, mode);
     }
     lchown(path, uid, gid, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.lchown.call(this, path, uid, gid, callback); // function lchown(path, uid, gid, callback) {
+        return nodeFS.lchown.call(this, path, uid, gid, callback || ((_err) => { }));
     }
     lchownSync(path, uid, gid) {
         this.#checkProtected(path, false);
-        return nodeFS.lchownSync.call(this, path, uid, gid); // function lchownSync(path, uid, gid) {
+        return nodeFS.lchownSync.call(this, path, uid, gid);
     }
     link(existingPath, newPath, callback) {
         this.#checkProtected(existingPath, false);
         this.#checkProtected(newPath, false);
-        return nodeFS.link.call(this, existingPath, newPath, callback); // function link(existingPath, newPath, callback) {
+        return nodeFS.link.call(this, existingPath, newPath, callback || ((_err) => { }));
     }
     linkSync(existingPath, newPath) {
         this.#checkProtected(existingPath, false);
         this.#checkProtected(newPath, false);
-        return nodeFS.linkSync.call(this, existingPath, newPath); // function linkSync(existingPath, newPath) {
+        return nodeFS.linkSync.call(this, existingPath, newPath);
     }
     lstat(path, options, callback) {
         this.#checkProtected(path, true);
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.lstat.call(this, path, options, callback);
+        }
         // @ts-expect-error should work
-        return nodeFS.lstat.call(this, path, options, callback); // function lstat(path, options = { bigint: false }, callback) {
+        return nodeFS.lstat.call(this, path, options);
     }
     lstatSync(path, options) {
         this.#checkProtected(path, true);
-        return nodeFS.lstatSync.call(this, path, options); // function lstatSync(path, options = { bigint: false, throwIfNoEntry: true }) {
+        return nodeFS.lstatSync.call(this, path, options);
     }
     lutimes(path, atime, mtime, callback) {
         this.#checkProtected(path, false);
-        return nodeFS.lutimes.call(this, path, atime, mtime, callback); // function lutimes(path, atime, mtime, callback) {
+        return nodeFS.lutimes.call(this, path, atime, mtime, callback || ((_err) => { }));
     }
     lutimesSync(path, atime, mtime) {
         this.#checkProtected(path, false);
-        return nodeFS.lutimesSync.call(this, path, atime, mtime); // function lutimesSync(path, atime, mtime) {
+        return nodeFS.lutimesSync.call(this, path, atime, mtime);
     }
     mkdir(path, options, callback) {
         this.#checkProtected(path, false);
-        // @ts-expect-error should work
-        return nodeFS.mkdir.call(this, path, options, callback); // function mkdir(path, options, callback) {
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.mkdir.call(this, path, options, callback);
+        }
+        return nodeFS.mkdir.call(this, path, options);
     }
     mkdirSync(path, options) {
         this.#checkProtected(path, false);
-        return nodeFS.mkdirSync.call(this, path, options); // function mkdirSync(path, options) {
+        return nodeFS.mkdirSync.call(this, path, options);
     }
     mkdtemp(prefix, options, callback) {
         this.#checkProtected(prefix, false);
-        // @ts-expect-error should work
-        return nodeFS.mkdtemp.call(this, prefix, options, callback); // function mkdtemp(prefix, options, callback) {
+        if (typeof callback === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.mkdtemp.call(this, prefix, options, callback);
+        }
+        return nodeFS.mkdtemp.call(this, prefix, options);
     }
     mkdtempSync(prefix, options) {
         this.#checkProtected(prefix, false);
-        return nodeFS.mkdtempSync.call(this, prefix, options); // function mkdtempSync(prefix, options) {
+        return nodeFS.mkdtempSync.call(this, prefix, options);
     }
     rm(path, options, callback) {
         this.#checkProtected(path, false);
+        if (typeof callback === 'function') {
+            return nodeFS.rm.call(this, path, options, callback);
+        }
         // @ts-expect-error should work
-        return nodeFS.rm.call(this, path, options, callback); // function rm(path, options, callback) {
+        return nodeFS.rm.call(this, path, options);
     }
     rmSync(path, options) {
         this.#checkProtected(path, false);
-        return nodeFS.rmSync.call(this, path, options); // function rmSync(path, options) {
+        return nodeFS.rmSync.call(this, path, options);
     }
     rmdir(path, options, callback) {
         this.#checkProtected(path, false);
+        if (typeof callback === 'function') {
+            return nodeFS.rmdir.call(this, path, options, callback);
+        }
         // @ts-expect-error should work
-        return nodeFS.rmdir.call(this, path, options, callback); // function rmdir(path, options, callback) {
+        return nodeFS.rmdir.call(this, path, options);
     }
     rmdirSync(path, options) {
         this.#checkProtected(path, false);
-        return nodeFS.rmdirSync.call(this, path, options); // function rmdirSync(path, options) {
+        return nodeFS.rmdirSync.call(this, path, options);
     }
-    watch(filename, listener) {
+    watch(filename, options, listener) {
         this.#checkProtected(filename, true);
-        return nodeFS.watch.call(this, filename, listener); // function watch(filename, options, listener) {
+        if (typeof listener === 'function') {
+            // @ts-expect-error should work
+            return nodeFS.watch.call(this, filename, options, listener);
+        }
+        return nodeFS.watch.call(this, filename, options);
     }
     watchFile(filename, listener) {
         this.#checkProtected(filename, true);
-        return nodeFS.watchFile.call(this, filename, listener); // function watchFile(filename, options, listener) {
+        return nodeFS.watchFile.call(this, filename, listener);
+    }
+    unwatchFile(filename, listener) {
+        this.#checkProtected(filename, true);
+        return nodeFS.unwatchFile.call(this, filename, listener);
     }
 }
 exports.default = ProtectFs;