jopi-toolkit 3.0.24 → 3.1.25

package/src/jk_fs/jBundler_ifServer.js

@@ -1,764 +0,0 @@
-// noinspection JSUnusedGlobalSymbols
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import fs from "node:fs/promises";
-import fss, { createReadStream, createWriteStream } from "node:fs";
-import { fileURLToPath as n_fileURLToPath, pathToFileURL as n_pathToFileURL } from "node:url";
-import { lookup } from "mime-types";
-import { Readable } from "node:stream";
-import path from "node:path";
-import { createHash } from "node:crypto";
-import { isBunJS } from "jopi-toolkit/jk_what";
-import AdmZip from 'adm-zip';
-var WebToNodeReadableStreamAdapter = /** @class */ (function (_super) {
-    __extends(WebToNodeReadableStreamAdapter, _super);
-    function WebToNodeReadableStreamAdapter(webStream) {
-        var _this = _super.call(this) || this;
-        _this.webStreamReader = webStream.getReader();
-        return _this;
-    }
-    WebToNodeReadableStreamAdapter.prototype._read = function () {
-        var _this = this;
-        this.webStreamReader.read().then(function (_a) {
-            var done = _a.done, value = _a.value;
-            if (done) {
-                _this.push(null);
-                return;
-            }
-            var buffer = Buffer.from(value);
-            if (!_this.push(buffer))
-                _this.webStreamReader.cancel().then();
-        }).catch(function (err) {
-            _this.destroy(err);
-        });
-    };
-    WebToNodeReadableStreamAdapter.prototype._destroy = function (err, callback) {
-        this.webStreamReader.cancel().finally(function () { callback(err); });
-    };
-    return WebToNodeReadableStreamAdapter;
-}(Readable));
-function writeResponseToFile_node(response_1, filePath_1) {
-    return __awaiter(this, arguments, void 0, function (response, filePath, createDir) {
-        var bufferDonnees, bufferNode;
-        if (createDir === void 0) { createDir = true; }
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!createDir) return [3 /*break*/, 2];
-                    return [4 /*yield*/, mkDir(path.dirname(filePath))];
-                case 1:
-                    _a.sent();
-                    _a.label = 2;
-                case 2: return [4 /*yield*/, response.arrayBuffer()];
-                case 3:
-                    bufferDonnees = _a.sent();
-                    bufferNode = Buffer.from(bufferDonnees);
-                    return [4 /*yield*/, fs.writeFile(filePath, bufferNode)];
-                case 4:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    });
-}
-export var writeResponseToFile = isBunJS
-    ? function (r, p) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, Bun.file(p).write(r)];
-            case 1:
-                _a.sent();
-                return [2 /*return*/];
-        }
-    }); }); }
-    : writeResponseToFile_node;
-export function nodeStreamToWebStream(nodeStream, debugInfos) {
-    var dataListener;
-    var endListener;
-    var errorListener;
-    return new ReadableStream({
-        start: function (controller) {
-            dataListener = function (chunk) {
-                try {
-                    controller.enqueue(chunk);
-                }
-                catch (e) {
-                    if (debugInfos) {
-                        console.log("nodeStreamToWebStream - enqueue failed for " + debugInfos, e);
-                    }
-                    nodeStream.destroy(new Error("WebStream controller closed unexpectedly"));
-                    nodeStream.off('data', dataListener);
-                    nodeStream.off('end', endListener);
-                    nodeStream.off('error', errorListener);
-                }
-            };
-            endListener = function () {
-                try {
-                    controller.close();
-                }
-                catch (e) {
-                    if (debugInfos) {
-                        console.log("nodeStreamToWebStream - close failed for " + debugInfos, e);
-                    }
-                }
-            };
-            errorListener = function (err) {
-                controller.error(err);
-                nodeStream.off('data', dataListener);
-                nodeStream.off('end', endListener);
-            };
-            nodeStream.on('data', dataListener);
-            nodeStream.on('end', endListener);
-            nodeStream.on('error', errorListener);
-        },
-        cancel: function (reason) {
-            if (debugInfos) {
-                console.log("nodeStreamToWebStream - stream cancelled for ".concat(debugInfos, ". Reason: ").concat(reason || 'Client disconnected'));
-            }
-            if (dataListener)
-                nodeStream.off('data', dataListener);
-            if (endListener)
-                nodeStream.off('end', endListener);
-            if (errorListener)
-                nodeStream.off('error', errorListener);
-            if (typeof nodeStream.destroy === 'function') {
-                nodeStream.destroy();
-            }
-        }
-    });
-}
-export function webStreamToNodeStream(webStream) {
-    return new WebToNodeReadableStreamAdapter(webStream);
-}
-function createResponseFromFile_node(filePath, status, headers) {
-    if (status === void 0) { status = 200; }
-    var nodeReadStream = createReadStream(filePath);
-    var webReadableStream = nodeStreamToWebStream(nodeReadStream, filePath);
-    return new Response(webReadableStream, { status: status, headers: headers });
-}
-export var createResponseFromFile = isBunJS
-    ? function (filePath, status, headers) {
-        if (status === void 0) { status = 200; }
-        return new Response(Bun.file(filePath), { status: status, headers: headers });
-    }
-    : createResponseFromFile_node;
-export function getFileSize(filePath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, fs.stat(filePath)];
-                case 1: return [2 /*return*/, (_b.sent()).size];
-                case 2:
-                    _a = _b.sent();
-                    return [2 /*return*/, 0];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
-}
-export function getFileStat(filePath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, fs.stat(filePath)];
-                case 1: return [2 /*return*/, _b.sent()];
-                case 2:
-                    _a = _b.sent();
-                    return [2 /*return*/, undefined];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
-}
-export function getMimeTypeFromName(fileName) {
-    var found = lookup(fileName);
-    if (found === false)
-        return "";
-    return found;
-}
-export function mkDir(dirPath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, fs.mkdir(dirPath, { recursive: true })];
-                case 1:
-                    _b.sent();
-                    return [2 /*return*/, true];
-                case 2:
-                    _a = _b.sent();
-                    return [2 /*return*/, false];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
-}
-export function rmDir(dirPath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, fs.rm(dirPath, { recursive: true, force: true })];
-                case 1:
-                    _b.sent();
-                    return [2 /*return*/, true];
-                case 2:
-                    _a = _b.sent();
-                    return [2 /*return*/, false];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
-}
-export var fileURLToPath = isBunJS
-    ? function (url) { return Bun.fileURLToPath(url); }
-    : n_fileURLToPath;
-export var pathToFileURL = isBunJS
-    ? function (fsPath) { return Bun.pathToFileURL(fsPath); }
-    : n_pathToFileURL;
-export function unlink(filePath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, fs.unlink(filePath)];
-                case 1:
-                    _b.sent();
-                    return [2 /*return*/, true];
-                case 2:
-                    _a = _b.sent();
-                    return [2 /*return*/, false];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
-}
-export function writeTextToFile(filePath_1, text_1) {
-    return __awaiter(this, arguments, void 0, function (filePath, text, createDir) {
-        if (createDir === void 0) { createDir = true; }
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!createDir) return [3 /*break*/, 2];
-                    return [4 /*yield*/, mkDir(path.dirname(filePath))];
-                case 1:
-                    _a.sent();
-                    _a.label = 2;
-                case 2: return [4 /*yield*/, fs.writeFile(filePath, text, { encoding: 'utf8', flag: 'w' })];
-                case 3:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    });
-}
-export function writeTextToFileSync(filePath, text, createDir) {
-    if (createDir === void 0) { createDir = true; }
-    if (createDir) {
-        try {
-            fss.mkdirSync(path.dirname(filePath), { recursive: true });
-        }
-        catch (_a) { }
-    }
-    fss.writeFileSync(filePath, text, { encoding: 'utf8', flag: 'w' });
-}
-export function readTextFromFile(filePath_1) {
-    return __awaiter(this, arguments, void 0, function (filePath, throwError) {
-        var _a;
-        if (throwError === void 0) { throwError = false; }
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (throwError) {
-                        return [2 /*return*/, fs.readFile(filePath, 'utf8')];
-                    }
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, fs.readFile(filePath, 'utf8')];
-                case 2: return [2 /*return*/, _b.sent()];
-                case 3:
-                    _a = _b.sent();
-                    // @ts-ignore
-                    return [2 /*return*/, undefined];
-                case 4: return [2 /*return*/];
-            }
-        });
-    });
-}
-export function readJsonFromFile(filePath_1) {
-    return __awaiter(this, arguments, void 0, function (filePath, throwError) {
-        var txt, txt, _a;
-        if (throwError === void 0) { throwError = false; }
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (!throwError) return [3 /*break*/, 2];
-                    return [4 /*yield*/, fs.readFile(filePath, 'utf8')];
-                case 1:
-                    txt = _b.sent();
-                    return [2 /*return*/, JSON.parse(txt)];
-                case 2:
-                    _b.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, fs.readFile(filePath, 'utf8')];
-                case 3:
-                    txt = _b.sent();
-                    return [2 /*return*/, JSON.parse(txt)];
-                case 4:
-                    _a = _b.sent();
-                    // @ts-ignore
-                    return [2 /*return*/, undefined];
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
-}
-export function readTextFromFileSync(filePath) {
-    return fss.readFileSync(filePath, 'utf8');
-}
-export function isFile(filePath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var stats;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getFileStat(filePath)];
-                case 1:
-                    stats = _a.sent();
-                    if (!stats)
-                        return [2 /*return*/, false];
-                    return [2 /*return*/, stats.isFile()];
-            }
-        });
-    });
-}
-export function isDirectory(filePath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var stats;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getFileStat(filePath)];
-                case 1:
-                    stats = _a.sent();
-                    if (!stats)
-                        return [2 /*return*/, false];
-                    return [2 /*return*/, stats.isDirectory()];
-            }
-        });
-    });
-}
-export function isDirectorySync(dirPath) {
-    try {
-        var stats = fss.statSync(dirPath);
-        return stats.isDirectory();
-    }
-    catch (_a) {
-    }
-    return false;
-}
-export function isFileSync(dirPath) {
-    try {
-        var stats = fss.statSync(dirPath);
-        return stats.isFile();
-    }
-    catch (_a) {
-    }
-    return false;
-}
-function readFileToBytes_node(filePath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var buffer;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, fs.readFile(filePath)];
-                case 1:
-                    buffer = _a.sent();
-                    return [2 /*return*/, new Uint8Array(buffer)];
-            }
-        });
-    });
-}
-export var readFileToBytes = isBunJS
-    ? function (filePath) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-        return [2 /*return*/, Bun.file(filePath).bytes()];
-    }); }); }
-    : readFileToBytes_node;
-export function getRelativePath(fromDir, absolutePath) {
-    return path.relative(fromDir, absolutePath);
-}
-export function dirItemFromFile(filePath) {
-    return {
-        name: basename(filePath),
-        fullPath: filePath,
-        isFile: true, isDirectory: false, isSymbolicLink: false
-    };
-}
-export function dirItemFromDir(dirPath) {
-    return {
-        name: basename(dirPath),
-        fullPath: dirPath,
-        isFile: false, isDirectory: true, isSymbolicLink: false
-    };
-}
-export function listDir(dirPath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var ditItems, result, _i, ditItems_1, dirItem, toAdd, stats;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, isDirectory(dirPath)];
-                case 1:
-                    if (!(_a.sent()))
-                        return [2 /*return*/, []];
-                    return [4 /*yield*/, fs.readdir(dirPath)];
-                case 2:
-                    ditItems = _a.sent();
-                    result = [];
-                    _i = 0, ditItems_1 = ditItems;
-                    _a.label = 3;
-                case 3:
-                    if (!(_i < ditItems_1.length)) return [3 /*break*/, 6];
-                    dirItem = ditItems_1[_i];
-                    toAdd = {
-                        name: dirItem,
-                        fullPath: path.join(dirPath, dirItem),
-                        isFile: false, isDirectory: false, isSymbolicLink: false
-                    };
-                    return [4 /*yield*/, fs.stat(toAdd.fullPath)];
-                case 4:
-                    stats = _a.sent();
-                    if (stats.isFile()) {
-                        toAdd.isFile = true;
-                        toAdd.isDirectory = false;
-                        toAdd.isSymbolicLink = false;
-                    }
-                    else if (stats.isDirectory()) {
-                        toAdd.isDirectory = true;
-                        toAdd.isFile = false;
-                        toAdd.isSymbolicLink = false;
-                    }
-                    else if (stats.isSymbolicLink()) {
-                        toAdd.isSymbolicLink = true;
-                        toAdd.isDirectory = false;
-                        toAdd.isFile = false;
-                    }
-                    else {
-                        return [3 /*break*/, 5];
-                    }
-                    result.push(toAdd);
-                    _a.label = 5;
-                case 5:
-                    _i++;
-                    return [3 /*break*/, 3];
-                case 6: return [2 /*return*/, result];
-            }
-        });
-    });
-}
-var MEGA = 1024 * 1024;
-function calcFileHash_bun(filePath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var file, _a, _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    file = Bun.file(filePath);
-                    return [4 /*yield*/, file.exists()];
-                case 1:
-                    if (!(_c.sent()))
-                        return [2 /*return*/, undefined];
-                    if (file.size > 10 * MEGA) {
-                        return [2 /*return*/, calcFileHash_bun_streamed(file)];
-                    }
-                    _b = (_a = Bun).hash;
-                    return [4 /*yield*/, file.arrayBuffer()];
-                case 2: return [2 /*return*/, _b.apply(_a, [_c.sent(), 12346]).toString()];
-            }
-        });
-    });
-}
-function calcFileHash_bun_streamed(file) {
-    return __awaiter(this, void 0, void 0, function () {
-        var stream, reader, hasher, _a, done, value;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    stream = file.stream();
-                    reader = stream.getReader();
-                    hasher = new Bun.CryptoHasher("sha256");
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, , 5, 6]);
-                    _b.label = 2;
-                case 2:
-                    if (!true) return [3 /*break*/, 4];
-                    return [4 /*yield*/, reader.read()];
-                case 3:
-                    _a = _b.sent(), done = _a.done, value = _a.value;
-                    if (done)
-                        return [3 /*break*/, 4];
-                    hasher.update(value);
-                    return [3 /*break*/, 2];
-                case 4: return [2 /*return*/, hasher.digest("hex")];
-                case 5:
-                    reader.releaseLock();
-                    return [7 /*endfinally*/];
-                case 6: return [2 /*return*/];
-            }
-        });
-    });
-}
-function calcFileHash_node(filePath) {
-    if (!isFile(filePath))
-        return Promise.resolve(undefined);
-    return new Promise(function (resolve, reject) {
-        var hash = createHash('sha256');
-        var stream = createReadStream(filePath);
-        stream.on('data', function (data) { return hash.update(data); });
-        stream.on('end', function () { return resolve(hash.digest('hex')); });
-        stream.on('error', function (error) { return reject(error); });
-    });
-}
-/**
- * Calculate the hash of a file.
- * Allows using it for HTTP ETag or another change proof.
- * This version is optimized to use streams and avoid loading the whole file in memory.
- */
-export var calcFileHash = isBunJS ? calcFileHash_bun : calcFileHash_node;
-/**
- * Convert a simple win32 path to a linux path.
- */
-export function win32ToLinuxPath(filePath) {
-    return filePath.replace(/\\/g, '/');
-}
-/**
- * Copy a directory recursively.
- * Is optimized for large files.
- */
-export function copyDirectory(srcDir, destDir) {
-    return __awaiter(this, void 0, void 0, function () {
-        var entries;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, isDirectory(srcDir)];
-                case 1:
-                    if (!(_a.sent())) {
-                        throw new Error("Directory doesn't exist : ".concat(srcDir));
-                    }
-                    return [4 /*yield*/, mkDir(destDir)];
-                case 2:
-                    _a.sent();
-                    return [4 /*yield*/, fs.readdir(srcDir, { withFileTypes: true })];
-                case 3:
-                    entries = _a.sent();
-                    return [4 /*yield*/, Promise.all(entries.map(function (entry) { return __awaiter(_this, void 0, void 0, function () {
-                            var srcPath, destPath, _a;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        srcPath = path.join(srcDir, entry.name);
-                                        destPath = path.join(destDir, entry.name);
-                                        if (!entry.isDirectory()) return [3 /*break*/, 2];
-                                        return [4 /*yield*/, copyDirectory(srcPath, destPath)];
-                                    case 1:
-                                        _b.sent();
-                                        return [3 /*break*/, 5];
-                                    case 2:
-                                        _b.trys.push([2, 4, , 5]);
-                                        return [4 /*yield*/, copyFile(srcPath, destPath)];
-                                    case 3:
-                                        _b.sent();
-                                        return [3 /*break*/, 5];
-                                    case 4:
-                                        _a = _b.sent();
-                                        console.warn("jk_fs.copyDirectory - Failed to copy file ".concat(srcPath));
-                                        return [3 /*break*/, 5];
-                                    case 5: return [2 /*return*/];
-                                }
-                            });
-                        }); }))];
-                case 4:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    });
-}
-/**
- * Copy of a file.
- * Is optimized for large files.
- */
-export function copyFile(srcPath, destPath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var stat, symStat;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getFileStat(srcPath)];
-                case 1:
-                    stat = _a.sent();
-                    if (!stat)
-                        return [2 /*return*/];
-                    if (!stat.isSymbolicLink()) return [3 /*break*/, 3];
-                    return [4 /*yield*/, fs.lstat(srcPath)];
-                case 2:
-                    symStat = _a.sent();
-                    if (!symStat)
-                        return [2 /*return*/];
-                    if (!symStat.isFile())
-                        return [2 /*return*/];
-                    _a.label = 3;
-                case 3: return [2 /*return*/, new Promise(function (resolve, reject) {
-                        var readStream = createReadStream(srcPath);
-                        var writeStream = createWriteStream(destPath);
-                        readStream.on('error', reject);
-                        writeStream.on('error', reject);
-                        writeStream.on('finish', resolve);
-                        readStream.pipe(writeStream);
-                    })];
-            }
-        });
-    });
-}
-/**
- * Unzip a .zip file in an optimized way.
- * Note was using : "@types/unzipper": "^0.10.11"
- * which has some bug, files/folders was forgottens.
- * import * as unzipper from "unzipper";
- */
-/*export async function unzipFile_old(zipFilePath: string, outputDir: string): Promise<void> {
-    if (!await isFile(zipFilePath)) {
-        throw new Error(`File doesn't exist : ${zipFilePath}`);
-    }
-
-    if (!await isDirectory(outputDir)) {
-        await mkDir(outputDir);
-    }
-
-    await createReadStream(zipFilePath)
-        .pipe(unzipper.Extract({path: outputDir}))
-        .promise();
-}*/
-/**
- * Unzip a .zip file in an optimized way.
- */
-export function unzipFile(zipFilePath, outputDir) {
-    return __awaiter(this, void 0, void 0, function () {
-        var zip;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, isFile(zipFilePath)];
-                case 1:
-                    if (!(_a.sent())) {
-                        throw new Error("File doesn't exist : ".concat(zipFilePath));
-                    }
-                    return [4 /*yield*/, isDirectory(outputDir)];
-                case 2:
-                    if (!!(_a.sent())) return [3 /*break*/, 4];
-                    return [4 /*yield*/, mkDir(outputDir)];
-                case 3:
-                    _a.sent();
-                    _a.label = 4;
-                case 4:
-                    zip = new AdmZip(zipFilePath);
-                    zip.extractAllTo(outputDir, true);
-                    return [2 /*return*/];
-            }
-        });
-    });
-}
-/**
- * Create a temporary directory.
- * Return an object containing the directory path and a cleanup function.
- */
-export function createTempDir(prefix) {
-    return __awaiter(this, void 0, void 0, function () {
-        var dirPath;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, fs.mkdtemp(prefix)];
-                case 1:
-                    dirPath = _a.sent();
-                    return [2 /*return*/, {
-                            path: dirPath,
-                            remove: function () { return __awaiter(_this, void 0, void 0, function () {
-                                return __generator(this, function (_a) {
-                                    return [2 /*return*/, fs.rm(dirPath, { recursive: true, force: true })];
-                                });
-                            }); }
-                        }];
-            }
-        });
-    });
-}
-//region Node.js functions
-export var join = path.join;
-export var resolve = path.resolve;
-export var dirname = path.dirname;
-export var extname = path.extname;
-export var sep = path.sep;
-export var isAbsolute = path.isAbsolute;
-export var normalize = path.normalize;
-export var basename = path.basename;
-export var symlink = fs.symlink;
-export var rename = fs.rename;
-//endregion