core-3nweb-client-lib 0.44.7 → 0.44.9

package/build/lib-common/async-fs-node.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2019, 2021 - 2022 3NSoft Inc.
+ Copyright (C) 2015 - 2019, 2021 - 2022, 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -16,24 +16,7 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Stats = void 0;
-exports.readFile = readFile;
-exports.writeFile = writeFile;
-exports.appendFile = appendFile;
-exports.mkdir = mkdir;
-exports.open = open;
-exports.close = close;
-exports.symlink = symlink;
-exports.readlink = readlink;
-exports.lstat = lstat;
-exports.stat = stat;
-exports.fstat = fstat;
-exports.readdir = readdir;
-exports.rmdir = rmdir;
-exports.unlink = unlink;
-exports.rename = rename;
-exports.truncate = truncate;
-exports.ftruncate = ftruncate;
+exports.truncate = exports.rename = exports.unlink = exports.rmdir = exports.readdir = exports.stat = exports.lstat = exports.readlink = exports.symlink = exports.open = exports.mkdir = exports.appendFile = exports.writeFile = exports.readFile = void 0;
 exports.readToBuf = readToBuf;
 exports.writeFromBuf = writeFromBuf;
 exports.createEmptyFile = createEmptyFile;
@@ -59,254 +42,31 @@ const deferred_1 = require("./processes/deferred");
 const bytes_fifo_buffer_1 = require("./byte-streaming/bytes-fifo-buffer");
 const buffer_utils_1 = require("./buffer-utils");
 const path_1 = require("path");
-var fs_2 = require("fs");
-Object.defineProperty(exports, "Stats", { enumerable: true, get: function () { return fs_2.Stats; } });
-function makeFileExceptionFromNodes(nodeExc) {
-    return (0, file_1.makeFileExceptionFromCode)(nodeExc.code, nodeExc.path);
+function makeFileExceptionFromNodesAndThrow(nodeExc) {
+    throw (0, file_1.makeFileExceptionFromCode)(nodeExc.code, nodeExc.path, undefined, 1);
 }
-function readFile(path, options) {
-    return new Promise((resolve, reject) => {
-        const cb = (err, data) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve(data);
-            }
-        };
-        if (options) {
-            fs.readFile(path, options, cb);
-        }
-        else {
-            fs.readFile(path, cb);
-        }
-    });
-}
-function writeFile(path, data, options = {}) {
-    return new Promise((resolve, reject) => {
-        fs.writeFile(path, data, options, err => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
-function appendFile(path, data, options = {}) {
-    return new Promise((resolve, reject) => {
-        fs.appendFile(path, data, options, err => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
-function mkdir(path, options) {
-    return new Promise((resolve, reject) => {
-        fs.mkdir(path, options, (err) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
-function open(path, flags) {
-    return new Promise((resolve, reject) => {
-        fs.open(path, flags, (err, df) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve(df);
-            }
-        });
-    });
-}
-function writeOrig(fd, buffer, offset, length, position) {
-    return new Promise((resolve, reject) => {
-        const cb = (err, written) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve(written);
-            }
-        };
-        if (typeof position === 'number') {
-            fs.write(fd, buffer, offset, length, position, cb);
-        }
-        else {
-            fs.write(fd, buffer, offset, length, cb);
-        }
-    });
-}
-function readOrig(fd, buffer, offset, length, position) {
-    return new Promise((resolve, reject) => {
-        fs.read(fd, buffer, offset, length, position, (err, bytesRead) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve(bytesRead);
-            }
-        });
-    });
-}
-function close(fd) {
-    return new Promise((resolve, reject) => {
-        fs.close(fd, (err) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
-function symlink(target, path, type) {
-    return new Promise((resolve, reject) => {
-        fs.symlink(target, path, type, (err) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
-function readlink(path) {
-    return new Promise((resolve, reject) => {
-        fs.readlink(path, (err, targetPath) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve(targetPath);
-            }
-        });
-    });
-}
-function lstat(path) {
-    return new Promise((resolve, reject) => {
-        fs.lstat(path, (err, stat) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve(stat);
-            }
-        });
-    });
-}
-function stat(path) {
-    return new Promise((resolve, reject) => {
-        fs.stat(path, (err, stat) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve(stat);
-            }
-        });
-    });
-}
-function fstat(fd) {
-    return new Promise((resolve, reject) => {
-        // from some moment, typing of fs.fstat is broken
-        fs.fstat(fd, (err, stat) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve(stat);
-            }
-        });
-    });
-}
-function readdir(path) {
-    return new Promise((resolve, reject) => {
-        fs.readdir(path, (err, list) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve(list);
-            }
-        });
-    });
-}
-function rmdir(path) {
-    return new Promise((resolve, reject) => {
-        fs.rmdir(path, (err) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
-function unlink(path) {
-    return new Promise((resolve, reject) => {
-        fs.unlink(path, (err) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
-function rename(oldPath, newPath) {
-    return new Promise((resolve, reject) => {
-        fs.rename(oldPath, newPath, (err) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
-function truncate(path, size) {
-    return new Promise((resolve, reject) => {
-        fs.truncate(path, size, (err) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
-function ftruncate(fd, size) {
-    return new Promise((resolve, reject) => {
-        fs.ftruncate(fd, size, (err) => {
-            if (err) {
-                reject(makeFileExceptionFromNodes(err));
-            }
-            else {
-                resolve();
-            }
-        });
-    });
+function wrapNodeFn(nodePromisingFn) {
+    return function wrapOfNodePromisingFn(...args) {
+        return nodePromisingFn.call(undefined, ...args).catch(makeFileExceptionFromNodesAndThrow);
+    };
 }
+function noop() { }
+exports.readFile = wrapNodeFn(fs.promises.readFile);
+exports.writeFile = wrapNodeFn(fs.promises.writeFile);
+exports.appendFile = wrapNodeFn(fs.promises.appendFile);
+exports.mkdir = wrapNodeFn(fs.promises.mkdir);
+exports.open = wrapNodeFn(fs.promises.open);
+exports.symlink = wrapNodeFn(fs.promises.symlink);
+exports.readlink = wrapNodeFn(fs.promises.readlink);
+exports.lstat = wrapNodeFn(fs.promises.lstat);
+exports.stat = wrapNodeFn(fs.promises.stat);
+exports.readdir = wrapNodeFn(fs.promises.readdir);
+exports.rmdir = wrapNodeFn(fs.promises.rmdir);
+exports.unlink = wrapNodeFn(fs.promises.unlink);
+exports.rename = wrapNodeFn(fs.promises.rename);
+exports.truncate = wrapNodeFn(fs.promises.truncate);
 /**
- * @param fd is an open file descriptor
+ * @param fh is an open file handle
  * @param pos is a position in the file, from which reading should start
  * @param buf is a buffer, into which bytes should be read from start to
  * the end, i.e. number of bytes that must be read is equal to the buffer's
@@ -316,13 +76,13 @@ function ftruncate(fd, size) {
  * The promise fails, if an end of file is encountered before entire buffer is
  * filled up with bytes.
  */
-async function readToBuf(fd, pos, buf) {
+async function readToBuf(fh, pos, buf) {
     if ((typeof pos !== 'number') || (pos < 0)) {
-        throw new Error('Illegal file position given: ' + pos);
+        throw new RangeError('Illegal file position given: ' + pos);
     }
     let bytesRead = 0;
     while (bytesRead < buf.length) {
-        const bNum = await readOrig(fd, buf, bytesRead, buf.length - bytesRead, pos);
+        const { bytesRead: bNum } = await fh.read(buf, bytesRead, buf.length - bytesRead, pos);
         if (bNum === 0) {
             throw (0, file_1.makeFileException)('endOfFile', '<file descriptor>');
         }
@@ -331,18 +91,18 @@ async function readToBuf(fd, pos, buf) {
     }
 }
 /**
- * @param fd is an open file descriptor
+ * @param fh is an open file handle
  * @param pos is a position in the file, from which writing should start
  * @param buf is a buffer, from which all bytes should be written into the file.
  * @returns a promise, resolvable when all bytes were written to the file.
  */
-async function writeFromBuf(fd, pos, buf) {
+async function writeFromBuf(fh, pos, buf) {
     if ((typeof pos !== 'number') || (pos < 0)) {
         throw new Error('Illegal file position given: ' + pos);
     }
     let bytesWritten = 0;
     while (bytesWritten < buf.length) {
-        const bNum = await writeOrig(fd, buf, bytesWritten, buf.length - bytesWritten, pos);
+        const { bytesWritten: bNum } = await fh.write(buf, bytesWritten, buf.length - bytesWritten, pos);
         bytesWritten += bNum;
         pos += bNum;
     }
@@ -356,27 +116,28 @@ SINGLE_BYTE_BUF[0] = 0;
  * @param fileSize
  * @param keepFileOpen
  * @returns a promise, resolvable, when a new empty file has been created.
- * When keep open flag was passed, live numeric file descriptor is returned,
+ * When keep open flag was passed, live file handle is returned,
  * else return value is undefined and should be ignored.
  */
 async function createEmptyFile(filePath, fileSize, keepFileOpen) {
     if ((typeof fileSize !== 'number') || (fileSize < 0)) {
-        throw new Error('Illegal file size given: ' + fileSize);
+        throw new RangeError('Illegal file size given: ' + fileSize);
     }
     let fileDescr;
     try {
-        fileDescr = await open(filePath, 'wx');
+        fileDescr = await (0, exports.open)(filePath, 'wx');
+        fileDescr.close();
         if (fileSize > 0) {
-            await writeOrig(fileDescr, SINGLE_BYTE_BUF, 0, 1, fileSize - 1);
+            await fileDescr.write(SINGLE_BYTE_BUF, 0, 1, fileSize - 1);
         }
         if (keepFileOpen) {
             return fileDescr;
         }
-        await close(fileDescr);
+        await fileDescr.close();
     }
     catch (exc) {
         if (fileDescr) {
-            close(fileDescr).catch(() => { });
+            fileDescr.close().catch(noop);
         }
         throw exc;
     }
@@ -388,7 +149,7 @@ async function createEmptyFile(filePath, fileSize, keepFileOpen) {
  */
 async function existsFolder(path) {
     try {
-        const stats = await stat(path);
+        const stats = await (0, exports.stat)(path);
         if (stats.isDirectory()) {
             return true;
         }
@@ -448,7 +209,7 @@ function existsFileSync(path) {
  * @return a promise, resolvable to file's size.
  */
 async function getFileSize(filePath) {
-    const st = await stat(filePath);
+    const st = await (0, exports.stat)(filePath);
     return st.size;
 }
 /**
@@ -457,11 +218,11 @@ async function getFileSize(filePath) {
  * @param folderPath
  */
 async function getFolderContentSize(folderPath) {
-    const list = await readdir(folderPath);
+    const list = await (0, exports.readdir)(folderPath);
     let size = 0;
     for (const childName of list) {
         const childPath = `${folderPath}/${childName}`;
-        const childStats = await stat(childPath);
+        const childStats = await (0, exports.stat)(childPath);
         if (childStats.isFile()) {
             size += childStats.size;
         }
@@ -472,31 +233,32 @@ async function getFolderContentSize(folderPath) {
     return size;
 }
 /**
- * @param fd is an open file descriptor
+ * @param fh is an open file handle
  * @param pos is a position in the file, from which writing should start
  * @param buf is a buffer, from which all bytes should be written into the file.
  * @returns a promise, resolvable when all bytes were written to it.
  */
-async function write(fd, pos, buf) {
+async function write(fh, pos, buf) {
     if ((typeof pos !== 'number') || (pos < 0)) {
-        throw new Error('Illegal file position given: ' + pos);
+        throw new RangeError('Illegal file position given: ' + pos);
     }
     let bytesWritten = 0;
     while (bytesWritten < buf.length) {
-        const bNum = await writeOrig(fd, buf, bytesWritten, buf.length - bytesWritten, pos);
+        const { bytesWritten: bNum } = await fh.write(buf, bytesWritten, buf.length - bytesWritten, pos);
         bytesWritten += bNum;
         pos += bNum;
     }
+    await fh.sync();
 }
 /**
- * @param fd is an open file descriptor in append mode.
+ * @param fh is an open file handle in append mode.
  * @param buf is a buffer, from which all bytes should be written into the file.
  * @returns a promise, resolvable when all bytes were written to it.
  */
-async function append(fd, buf) {
+async function append(fh, buf) {
     let bytesWritten = 0;
     while (bytesWritten < buf.length) {
-        const bNum = await writeOrig(fd, buf, bytesWritten, buf.length - bytesWritten);
+        const { bytesWritten: bNum } = await fh.write(buf, bytesWritten, buf.length - bytesWritten);
         bytesWritten += bNum;
     }
 }
@@ -507,12 +269,12 @@ async function append(fd, buf) {
  * @returns a promise, resolvable when all bytes were written to it.
  */
 async function writeToExistingFile(filePath, pos, buf) {
-    const fd = await open(filePath, 'r+');
+    const fh = await (0, exports.open)(filePath, 'r+');
     try {
-        await write(fd, pos, buf);
+        await write(fh, pos, buf);
     }
     finally {
-        await close(fd);
+        await fh.close();
     }
 }
 /**
@@ -527,10 +289,10 @@ async function writeToExistingFile(filePath, pos, buf) {
  */
 async function streamToExistingFile(filePath, pos, len, src, bufSize) {
     if ((typeof pos !== 'number') || (pos < 0)) {
-        throw new Error('Illegal file position given: ' + pos);
+        throw new RangeError('Illegal file position given: ' + pos);
     }
     if ((typeof len !== 'number') || (len < 1)) {
-        throw new Error('Illegal length given: ' + len);
+        throw new RangeError('Illegal length given: ' + len);
     }
     if ((typeof bufSize !== 'number') || (bufSize < 1024)) {
         throw new Error('Illegal buffer size given: ' + bufSize);
@@ -602,7 +364,7 @@ async function streamToExistingFile(filePath, pos, len, src, bufSize) {
     return deferred.promise;
 }
 /**
- * @param fd is an open file descriptor
+ * @param fh is an open file handle
  * @param pos is a position in the file, from which reading should start
  * @param buf is a buffer, into which bytes should be read from start to
  * the end, i.e. number of bytes that must be read is equal to the buffer's
@@ -612,13 +374,13 @@ async function streamToExistingFile(filePath, pos, len, src, bufSize) {
  * The promise fails, if an end of file is encountered before entire buffer is
  * filled up with bytes.
  */
-async function read(fd, pos, buf) {
+async function read(fh, pos, buf) {
     if ((typeof pos !== 'number') || (pos < 0)) {
-        throw new Error('Illegal file position given: ' + pos);
+        throw new RangeError('Illegal file position given: ' + pos);
     }
     let bytesRead = 0;
     while (bytesRead < buf.length) {
-        const bNum = await readOrig(fd, buf, bytesRead, buf.length - bytesRead, pos);
+        const { bytesRead: bNum } = await fh.read(buf, bytesRead, buf.length - bytesRead, pos);
         if (bNum === 0) {
             throw (0, file_1.makeFileException)('endOfFile', '<file descriptor>');
         }
@@ -638,12 +400,12 @@ async function read(fd, pos, buf) {
  * filled up with bytes.
  */
 async function readFromFile(filePath, pos, buf) {
-    const fd = await open(filePath, 'r');
+    const fh = await (0, exports.open)(filePath, 'r');
     try {
-        return read(fd, pos, buf);
+        return read(fh, pos, buf);
     }
     finally {
-        return close(fd);
+        return fh.close();
     }
 }
 /**
@@ -652,27 +414,27 @@ async function readFromFile(filePath, pos, buf) {
  * @returns a promise, resolvable, when a folder has been recursively removed.
  */
 async function rmDirWithContent(folder) {
-    const files = await readdir(folder);
+    const files = await (0, exports.readdir)(folder);
     if (files.length === 0) {
-        await rmdir(folder);
+        await (0, exports.rmdir)(folder);
         return;
     }
     const rmTasks = [];
     for (const name of files) {
         const innerPath = `${folder}/${name}`;
-        const task = lstat(innerPath)
+        const task = (0, exports.lstat)(innerPath)
             .then((st) => {
             if (st.isDirectory()) {
                 return rmDirWithContent(innerPath);
             }
             else {
-                return unlink(innerPath);
+                return (0, exports.unlink)(innerPath);
             }
         });
         rmTasks.push(task);
     }
     await Promise.all(rmTasks);
-    await rmdir(folder);
+    await (0, exports.rmdir)(folder);
 }
 /**
  * @param w is a writable stream
@@ -765,19 +527,19 @@ function copyFile(src, dst, overwrite = false, dstMode = '660') {
  */
 async function copyTree(src, dst, fileOverwrite = false) {
     // destination folder, non-exclusively
-    await mkdir(dst, { recursive: true })
+    await (0, exports.mkdir)(dst, { recursive: true })
         .catch(async (exc) => {
         if (!exc.alreadyExists) {
             throw exc;
         }
     });
     // copy files and folders from src folder
-    const srcFNames = await readdir(src);
+    const srcFNames = await (0, exports.readdir)(src);
     const cpTasks = [];
     for (const fName of srcFNames) {
         const srcPath = (0, path_1.join)(src, fName);
         const dstPath = (0, path_1.join)(dst, fName);
-        const task = stat(srcPath)
+        const task = (0, exports.stat)(srcPath)
             .then((stats) => {
             if (stats.isFile()) {
                 return copyFile(srcPath, dstPath, fileOverwrite);
@@ -797,11 +559,11 @@ async function copyTree(src, dst, fileOverwrite = false) {
  * @param path is a folder path
  */
 async function ensureFolderExists(path) {
-    await stat(path).catch(async (exc) => {
+    await (0, exports.stat)(path).catch(async (exc) => {
         if (!exc.notFound) {
             throw exc;
         }
-        await mkdir(path, { recursive: true })
+        await (0, exports.mkdir)(path, { recursive: true })
             .catch(async (exc) => {
             if (!exc.alreadyExists) {
                 throw exc;

package/build/lib-common/awaitable-state.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2017 3NSoft Inc.
+ Copyright (C) 2026 3NSoft Inc.
 
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -40,4 +40,6 @@ class AwaitableState {
     }
 }
 exports.AwaitableState = AwaitableState;
+Object.freeze(AwaitableState.prototype);
+Object.freeze(AwaitableState);
 Object.freeze(exports);

package/build/lib-common/exceptions/file.d.ts

@@ -1,7 +1,7 @@
 export type FileException = web3n.files.FileException;
 export type FileExceptionFlag = web3n.files.FileExceptionFlag;
 export declare const Code: web3n.files.exceptionCode;
-export declare function makeFileExceptionFromCode(code: string | undefined, path: string, cause?: any): FileException;
+export declare function makeFileExceptionFromCode(code: string | undefined, path: string, cause?: any, numOfTopLayersToRemove?: number): FileException;
 export declare function makeFileException(flag: keyof FileExceptionFlag, path: string, cause?: any): FileException;
 export declare function maskPathInExc(pathPrefixMaskLen: number, exc: any): FileException;
 export declare function ensureCorrectFS(fs: web3n.files.FS, type: web3n.files.FSType, writable: boolean): void;

package/build/lib-common/exceptions/file.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2018, 2020 - 2022 3NSoft Inc.
+ Copyright (C) 2015 - 2018, 2020 - 2022, 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -23,6 +23,7 @@ exports.maskPathInExc = maskPathInExc;
 exports.ensureCorrectFS = ensureCorrectFS;
 exports.makeNoAttrsExc = makeNoAttrsExc;
 exports.makeVersionMismatchExc = makeVersionMismatchExc;
+const runtime_1 = require("./runtime");
 exports.Code = {
     notFound: 'ENOENT',
     alreadyExists: 'EEXIST',
@@ -41,13 +42,14 @@ const codeToFlag = {};
 for (const [flag, code] of Object.entries(exports.Code)) {
     codeToFlag[code] = flag;
 }
-function makeFileExceptionFromCode(code, path, cause) {
+function makeFileExceptionFromCode(code, path, cause, numOfTopLayersToRemove = 0) {
     const err = {
         runtimeException: true,
         type: 'file',
         code,
         path,
-        cause
+        cause,
+        stack: (0, runtime_1.getStackHere)(1 + numOfTopLayersToRemove)
     };
     if (code) {
         const flag = codeToFlag[code];
@@ -64,7 +66,8 @@ function makeFileException(flag, path, cause) {
         type: 'file',
         code,
         path,
-        cause
+        cause,
+        stack: (0, runtime_1.getStackHere)(1)
     };
     err[flag] = true;
     return err;
@@ -95,7 +98,8 @@ function makeNoAttrsExc(path) {
         type: 'file',
         code: undefined,
         path,
-        attrsNotEnabledInFS: true
+        attrsNotEnabledInFS: true,
+        stack: (0, runtime_1.getStackHere)(1)
     };
 }
 function makeVersionMismatchExc(path, message) {
@@ -105,7 +109,8 @@ function makeVersionMismatchExc(path, message) {
         code: undefined,
         path,
         versionMismatch: true,
-        message
+        message,
+        stack: (0, runtime_1.getStackHere)(1)
     };
 }
 Object.freeze(exports);

package/build/lib-common/exceptions/runtime.d.ts

@@ -1 +1,7 @@
-export declare function makeRuntimeException<T extends web3n.RuntimeException>(type: NonNullable<T['type']>, params: Partial<T>, flags: Partial<T>): T;
+export declare function makeRuntimeException<T extends web3n.RuntimeException>(type: NonNullable<T['type']>, params: Partial<T>, flags: Partial<T>, addStack?: boolean): T;
+/**
+ *
+ * @param numOfTopLayersToRemove
+ * @returns
+ */
+export declare function getStackHere(numOfTopLayersToRemove?: number): string | undefined;