tnp-core 18.0.47 → 18.0.50

package/lib/utils.js

@@ -1,28 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilsTerminal = exports.UtilsMigrations = exports.UtilsString = exports.UtilsOs = exports.UtilsProcess = exports.Utils = void 0;
-var tslib_1 = require("tslib");
-var core_models_1 = require("./core-models");
-var axios_1 = require("axios");
-var core_imports_1 = require("./core-imports");
-var index_1 = require("./index");
-var core_imports_2 = require("./core-imports");
-//#region @backend
-var core_imports_3 = require("./core-imports");
-var core_imports_4 = require("./core-imports");
-var buffer_1 = require("buffer");
-var net = require("net");
+//#region imports
+const buffer_1 = require("buffer");
+const net = require("net");
+const util_1 = require("util");
+const axios_1 = require("axios");
+const core_imports_1 = require("./core-imports");
+const core_imports_2 = require("./core-imports");
+const core_imports_3 = require("./core-imports");
+const core_imports_4 = require("./core-imports");
+const core_models_1 = require("./core-models");
+const index_1 = require("./index");
 //#endregion
-var BLOB_SUPPORTED_IN_SQLJS = false;
+const BLOB_SUPPORTED_IN_SQLJS = false;
 //#region utils
 var Utils;
 (function (Utils) {
-    var _this = this;
     //#region utils / uniq array
-    Utils.uniqArray = function (array, uniqueProperty) {
+    Utils.uniqArray = (array, uniqueProperty) => {
         var seen = {};
         return array
-            .filter(function (f) { return !!f; })
+            .filter(f => !!f)
             .filter(function (item) {
             return seen.hasOwnProperty(uniqueProperty ? item[uniqueProperty] : item)
                 ? false
@@ -30,95 +29,165 @@ var Utils;
         });
     };
     //#endregion
+    //#region utils / recursive sort keys in object
+    /**
+     * @param anyObject
+     * @returns object with sorted keys
+     */
+    Utils.sortKeys = (anyObject) => {
+        if (core_imports_1._.isArray(anyObject)) {
+            return anyObject.map(Utils.sortKeys);
+        }
+        if (core_imports_1._.isObject(anyObject)) {
+            return core_imports_1._.fromPairs(core_imports_1._.keys(anyObject)
+                .sort()
+                .map(key => [key, Utils.sortKeys(anyObject[key])]));
+        }
+        return anyObject;
+    };
+    //#endregion
     //#region utils / escape string for reg exp
     /**
      * Example:
      * new RegExp(escapeStringForRegEx('a.b.c'),'g') => /a\.b\.c/g
      */
-    Utils.escapeStringForRegEx = function (stringForRegExp) {
+    Utils.escapeStringForRegEx = (stringForRegExp) => {
         return stringForRegExp.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
     };
     //#endregion
     //#region utils / remove chalk special chars
     function removeChalkSpecialChars(str) {
         // Regex to match ANSI escape sequences used by Chalk
-        var ansiRegex = /\u001b\[[0-9;]*m/g;
+        const ansiRegex = /\u001b\[[0-9;]*m/g;
         // Replace all ANSI escape sequences with an empty string
         return str.replace(ansiRegex, '');
     }
     Utils.removeChalkSpecialChars = removeChalkSpecialChars;
     //#endregion
     //#region utils / full date time
-    Utils.fullDateTime = function () {
+    Utils.fullDateTime = () => {
         //#region @backendFunc
         return (0, core_imports_2.dateformat)(new Date(), 'dd-mm-yyyy HH:MM:ss');
         //#endregion
     };
     //#endregion
     //#region utils / full date
-    Utils.fullDate = function () {
+    Utils.fullDate = () => {
         //#region @backendFunc
         return (0, core_imports_2.dateformat)(new Date(), 'dd-mm-yyyy');
         //#endregion
     };
     //#endregion
     //#region utils / get free port
-    var takenPorts = [];
-    Utils.getFreePort = function (options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var startFrom, max, i, port, err_1;
-        return tslib_1.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    //#region @backendFunc
-                    options = options || {};
-                    options.startFrom = options.startFrom || 3000;
-                    startFrom = options.startFrom;
-                    max = 5000;
-                    i = 0;
-                    _a.label = 1;
-                case 1:
-                    if (!true) return [3 /*break*/, 6];
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, UtilsOs.isPortInUse(startFrom)];
-                case 3:
-                    if (_a.sent()) {
-                        startFrom += 1;
-                        return [3 /*break*/, 1];
-                    }
-                    port = startFrom;
-                    takenPorts.push(port);
-                    return [2 /*return*/, port];
-                case 4:
-                    err_1 = _a.sent();
-                    console.log(err_1);
-                    index_1.Helpers.warn("Trying to assign port  :".concat(startFrom, " but already in use."), false);
-                    return [3 /*break*/, 5];
-                case 5:
+    const takenPorts = [];
+    Utils.getFreePort = async (options) => {
+        //#region @backendFunc
+        options = options || {};
+        options.startFrom = options.startFrom || 3000;
+        let startFrom = options.startFrom;
+        const max = 5000;
+        let i = 0;
+        while (true) {
+            try {
+                if (await UtilsOs.isPortInUse(startFrom)) {
                     startFrom += 1;
-                    if (i++ === max) {
-                        index_1.Helpers.error("[taon-helpers]] failed to assign free port after ".concat(max, " trys..."));
-                    }
-                    return [3 /*break*/, 1];
-                case 6: return [2 /*return*/];
+                    continue;
+                }
+                const port = startFrom;
+                takenPorts.push(port);
+                return port;
+            }
+            catch (err) {
+                console.log(err);
+                index_1.Helpers.warn(`Trying to assign port  :${startFrom} but already in use.`, false);
+            }
+            startFrom += 1;
+            if (i++ === max) {
+                index_1.Helpers.error(`[taon-helpers]] failed to assign free port after ${max} trys...`);
+            }
+        }
+        //#endregion
+    };
+    //#endregion
+    //#region utils / required uncached
+    /**
+     * Traverses the cache to search for all the cached
+     * files of the specified module name
+     */
+    const searchCache = (moduleName, callback) => {
+        //#region @backendFunc
+        // Resolve the module identified by the specified name
+        var mod = require.resolve(moduleName);
+        // Check if the module has been resolved and found within
+        // the cache
+        if (mod && (mod = require.cache[mod]) !== undefined) {
+            // Recursively go over the results
+            (function traverse(mod) {
+                // Go over each of the module's children and
+                // traverse them
+                mod['children'].forEach(function (child) {
+                    traverse(child);
+                });
+                // Call the specified callback providing the
+                // found cached module
+                callback(mod);
+            })(mod);
+        }
+        //#endregion
+    };
+    /**
+     * Removes a module from the cache
+     */
+    const purgeCache = moduleName => {
+        //#region @backendFunc
+        // Traverse the cache looking for the files
+        // loaded by the specified module name
+        searchCache(moduleName, function (mod) {
+            delete require.cache[mod.id];
+        });
+        // Remove cached paths to the module.
+        // Thanks to @bentael for pointing this out.
+        Object.keys(module.constructor['_pathCache']).forEach(function (cacheKey) {
+            if (cacheKey.indexOf(moduleName) > 0) {
+                delete module.constructor['_pathCache'][cacheKey];
             }
         });
-    }); };
-    var json;
+        //#endregion
+    };
+    Utils.requireUncached = (module) => {
+        //#region @backendFunc
+        const result = core_imports_1._.cloneDeep(require(module));
+        purgeCache(module);
+        return result;
+        //#endregion
+    };
+    //#endregion
+    //#region utils / camelize
+    /**
+     * similar to camelCase but remove
+     * all non word / repeated characters
+     */
+    Utils.camelize = (str = '') => {
+        str = str.replace(/\W/g, '').toLowerCase();
+        return str
+            .replace(/(?:^\w|[A-Z]|\b\w)/g, function (word, index) {
+            return index == 0 ? word.toLowerCase() : word.toUpperCase();
+        })
+            .replace(/\s+/g, '');
+    };
+    let json;
     (function (json) {
-        json.getAtrributies = function (jsonDeepPath, // lodash path to property in json ex. deep.path.to.prop
-        fileContent) {
-            var e_1, _a;
-            var lines = fileContent.split('\n');
+        json.getAtrributies = (jsonDeepPath, // lodash path to property in json ex. deep.path.to.prop
+        fileContent) => {
+            const lines = fileContent.split('\n');
             // split path to parts but keep part if is for example 'sql.js
-            var pathParts = jsonDeepPath.split('.').reduce(function (a, b) {
+            const pathParts = jsonDeepPath.split('.').reduce((a, b) => {
                 if (a.length === 0) {
                     return [b];
                 }
-                var last = a[a.length - 1];
-                if ((last.startsWith("['") && b.endsWith("']")) ||
-                    (last.startsWith("[\"") && b.endsWith("\"]"))) {
+                const last = a[a.length - 1];
+                if ((last.startsWith(`['`) && b.endsWith(`']`)) ||
+                    (last.startsWith(`["`) && b.endsWith(`"]`))) {
                     a[a.length - 1] = [last, b].join('.');
                 }
                 else {
@@ -128,100 +197,76 @@ var Utils;
             }, []);
             // console.log({ pathParts });
             // const pathParts = jsonDeepPath.split('.');
-            var keyName = pathParts.pop().replace(/^\["(.+)"\]$/, '$1');
-            var currentPath = '';
-            var attributes = [];
-            var collectedComments = [];
-            try {
-                for (var lines_1 = tslib_1.__values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
-                    var line = lines_1_1.value;
-                    var trimmedLine = line.trim();
-                    if (trimmedLine.startsWith('//')) {
-                        // Collect comments
-                        collectedComments.push(trimmedLine);
-                        // trimmedLine.startsWith('//pizda') &&
-                        //   console.log('pushlin line', { trimmedLine });
-                    }
-                    else if (trimmedLine.startsWith('"') || trimmedLine.startsWith("'")) {
-                        // Extract the key from the line
-                        var match = trimmedLine.match(/["']([^"']+)["']\s*:/);
-                        // console.log({ match0: match && match[0], match1: match && match[1] });
-                        if (match) {
-                            var key = match[1];
-                            currentPath = currentPath
-                                ? "".concat(currentPath, ".").concat(key.includes('.') ? "['".concat(key, "']") : key)
-                                : key;
-                            // console.log({ key });
-                            // Check if the current path matches the jsonDeepPath
-                            if ((currentPath.endsWith(keyName) &&
-                                !currentPath.endsWith('/' + keyName)) ||
-                                currentPath.endsWith("['".concat(keyName, "']"))) {
-                                // console.log('extract attributes', {
-                                //   keyName,
-                                //   collectedCommentsLength: collectedComments.length,
-                                // });
-                                // Process the collected comments to extract attributes
-                                attributes = extractAttributesFromComments(collectedComments);
-                                break;
-                            }
-                            // Reset collected comments as they only relate to the next key
-                            collectedComments = [];
+            const keyName = pathParts.pop().replace(/^\["(.+)"\]$/, '$1');
+            let currentPath = '';
+            let attributes = [];
+            let collectedComments = [];
+            for (const line of lines) {
+                const trimmedLine = line.trim();
+                if (trimmedLine.startsWith('//')) {
+                    // Collect comments
+                    collectedComments.push(trimmedLine);
+                    // trimmedLine.startsWith('//pizda') &&
+                    //   console.log('pushlin line', { trimmedLine });
+                }
+                else if (trimmedLine.startsWith('"') || trimmedLine.startsWith("'")) {
+                    // Extract the key from the line
+                    const match = trimmedLine.match(/["']([^"']+)["']\s*:/);
+                    // console.log({ match0: match && match[0], match1: match && match[1] });
+                    if (match) {
+                        const key = match[1];
+                        currentPath = currentPath
+                            ? `${currentPath}.${key.includes('.') ? `['${key}']` : key}`
+                            : key;
+                        // console.log({ key });
+                        // Check if the current path matches the jsonDeepPath
+                        if ((currentPath.endsWith(keyName) &&
+                            !currentPath.endsWith('/' + keyName)) ||
+                            currentPath.endsWith(`['${keyName}']`)) {
+                            // console.log('extract attributes', {
+                            //   keyName,
+                            //   collectedCommentsLength: collectedComments.length,
+                            // });
+                            // Process the collected comments to extract attributes
+                            attributes = extractAttributesFromComments(collectedComments);
+                            break;
                         }
+                        // Reset collected comments as they only relate to the next key
+                        collectedComments = [];
                     }
                 }
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (lines_1_1 && !lines_1_1.done && (_a = lines_1.return)) _a.call(lines_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
             return attributes;
         };
-        var extractAttributesFromComments = function (comments) {
-            var e_2, _a;
-            var attributes = [];
-            var attrRegex = /@(\w+)(?:\s*=\s*([^\s@]+))?/g;
-            try {
-                // console.log({ comments });
-                for (var comments_1 = tslib_1.__values(comments), comments_1_1 = comments_1.next(); !comments_1_1.done; comments_1_1 = comments_1.next()) {
-                    var comment = comments_1_1.value;
-                    var match = void 0;
-                    var _loop_1 = function () {
-                        var _b = tslib_1.__read(match, 3), name_1 = _b[1], value = _b[2];
-                        var existingAttribute = attributes.find(function (attr) { return attr.name === "@".concat(name_1); });
-                        if (existingAttribute) {
-                            if (value) {
-                                if (Array.isArray(existingAttribute.value)) {
-                                    existingAttribute.value.push(value);
-                                }
-                                else {
-                                    existingAttribute.value = [existingAttribute.value, value];
-                                }
+        const extractAttributesFromComments = (comments) => {
+            const attributes = [];
+            const attrRegex = /@(\w+)(?:\s*=\s*([^\s@]+))?/g;
+            // console.log({ comments });
+            for (const comment of comments) {
+                let match;
+                while ((match = attrRegex.exec(comment)) !== null) {
+                    const [, name, value] = match;
+                    const existingAttribute = attributes.find(attr => attr.name === `@${name}`);
+                    if (existingAttribute) {
+                        if (value) {
+                            if (Array.isArray(existingAttribute.value)) {
+                                existingAttribute.value.push(value);
+                            }
+                            else {
+                                existingAttribute.value = [existingAttribute.value, value];
                             }
                         }
-                        else {
-                            attributes.push({
-                                name: "@".concat(name_1),
-                                value: value ? value : true,
-                            });
-                        }
-                    };
-                    while ((match = attrRegex.exec(comment)) !== null) {
-                        _loop_1();
+                    }
+                    else {
+                        attributes.push({
+                            name: `@${name}`,
+                            value: value ? value : true,
+                        });
                     }
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (comments_1_1 && !comments_1_1.done && (_a = comments_1.return)) _a.call(comments_1);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
             // Normalize single values not to be arrays
-            attributes.forEach(function (attr) {
+            attributes.forEach(attr => {
                 if (Array.isArray(attr.value) && attr.value.length === 1) {
                     attr.value = attr.value[0];
                 }
@@ -232,7 +277,7 @@ var Utils;
     //#endregion
     //#region binary
     //#region db binary format type
-    var DbBinaryFormatEnum;
+    let DbBinaryFormatEnum;
     (function (DbBinaryFormatEnum) {
         DbBinaryFormatEnum["Blob"] = "Blob";
         DbBinaryFormatEnum["File"] = "File";
@@ -243,7 +288,7 @@ var Utils;
     })(DbBinaryFormatEnum = Utils.DbBinaryFormatEnum || (Utils.DbBinaryFormatEnum = {}));
     //#endregion
     //#endregion
-    var binary;
+    let binary;
     (function (binary) {
         //#region binay utils / array buffer to blob
         /* */
@@ -268,21 +313,14 @@ var Utils;
          * @param blob
          * @returns
          */
-        function blobToArrayBuffer(blob) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, new Promise(function (resolve, reject) {
-                                var reader = new FileReader();
-                                reader.addEventListener('loadend', function () {
-                                    resolve(reader.result);
-                                });
-                                reader.addEventListener('error', reject); // @ts-ignore
-                                reader.readAsArrayBuffer(blob);
-                            })];
-                        case 1: return [2 /*return*/, _a.sent()];
-                    }
+        async function blobToArrayBuffer(blob) {
+            return await new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.addEventListener('loadend', () => {
+                    resolve(reader.result);
                 });
+                reader.addEventListener('error', reject); // @ts-ignore
+                reader.readAsArrayBuffer(blob);
             });
         }
         binary.blobToArrayBuffer = blobToArrayBuffer;
@@ -294,9 +332,9 @@ var Utils;
          * @returns
          */
         function blobToBase64(blob) {
-            return new Promise(function (resolve, _) {
-                var reader = new FileReader();
-                reader.onloadend = function () { return resolve(reader.result); }; // @ts-ignore
+            return new Promise((resolve, _) => {
+                const reader = new FileReader();
+                reader.onloadend = () => resolve(reader.result); // @ts-ignore
                 reader.readAsDataURL(blob);
             });
         }
@@ -308,419 +346,242 @@ var Utils;
          * @param base64Data
          * @returns
          */
-        function base64toBlob(base64Data, contentTypeOverride) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var content_type, file_base64, m, _a, __, contenttype, filebase64, sliceSize, byteCharacters, bytesLength, slicesCount, byteArrays, sliceIndex, begin, end, bytes, offset, i;
-                return tslib_1.__generator(this, function (_b) {
-                    content_type = void 0;
-                    file_base64 = void 0;
-                    if (!contentTypeOverride) {
-                        m = /^data:(.+?);base64,(.+)$/.exec(base64Data);
-                        if (!m) {
-                            throw new Error("[taon-framework][base64toBlob] Not a base64 blob [".concat(base64Data, "]"));
-                        }
-                        _a = tslib_1.__read(m, 3), __ = _a[0], contenttype = _a[1], filebase64 = _a[2];
-                        content_type = contenttype;
-                        file_base64 = filebase64;
-                    }
-                    content_type = (contentTypeOverride ? contentTypeOverride : content_type || '');
-                    base64Data = contentTypeOverride ? base64Data : file_base64;
-                    sliceSize = 1024;
-                    byteCharacters = atob(base64Data);
-                    bytesLength = byteCharacters.length;
-                    slicesCount = Math.ceil(bytesLength / sliceSize);
-                    byteArrays = new Array(slicesCount);
-                    for (sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
-                        begin = sliceIndex * sliceSize;
-                        end = Math.min(begin + sliceSize, bytesLength);
-                        bytes = new Array(end - begin);
-                        // tslint:disable-next-line:one-variable-per-declaration
-                        for (offset = begin, i = 0; offset < end; ++i, ++offset) {
-                            bytes[i] = byteCharacters[offset].charCodeAt(0);
-                        }
-                        byteArrays[sliceIndex] = new Uint8Array(bytes);
-                    }
-                    return [2 /*return*/, new buffer_1.Blob(byteArrays, { type: content_type })];
-                });
-            });
+        async function base64toBlob(base64Data, contentTypeOverride) {
+            let content_type = void 0;
+            let file_base64 = void 0;
+            if (!contentTypeOverride) {
+                const m = /^data:(.+?);base64,(.+)$/.exec(base64Data);
+                if (!m) {
+                    throw new Error(`[taon-framework][base64toBlob] Not a base64 blob [${base64Data}]`);
+                }
+                // tslint:disable-next-line:prefer-const
+                var [__, contenttype, filebase64] = m;
+                content_type = contenttype;
+                file_base64 = filebase64;
+            }
+            content_type = (contentTypeOverride ? contentTypeOverride : content_type || '');
+            base64Data = contentTypeOverride ? base64Data : file_base64;
+            const sliceSize = 1024;
+            const byteCharacters = atob(base64Data);
+            const bytesLength = byteCharacters.length;
+            const slicesCount = Math.ceil(bytesLength / sliceSize);
+            const byteArrays = new Array(slicesCount);
+            for (let sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
+                const begin = sliceIndex * sliceSize;
+                const end = Math.min(begin + sliceSize, bytesLength);
+                const bytes = new Array(end - begin);
+                // tslint:disable-next-line:one-variable-per-declaration
+                for (let offset = begin, i = 0; offset < end; ++i, ++offset) {
+                    bytes[i] = byteCharacters[offset].charCodeAt(0);
+                }
+                byteArrays[sliceIndex] = new Uint8Array(bytes);
+            }
+            return new buffer_1.Blob(byteArrays, { type: content_type });
         }
         binary.base64toBlob = base64toBlob;
         //#endregion
         //#region binay utils / base64 string to db binary format
-        function base64toDbBinaryFormat(text) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var result;
-                var _this = this;
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, (function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var buffer;
-                                return tslib_1.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, base64toBuffer(text)];
-                                        case 1:
-                                            buffer = _a.sent();
-                                            return [2 /*return*/, buffer];
-                                    }
-                                });
-                            }); })()];
-                        case 1:
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            //#region @backend
-                            result = _a.sent();
-                            //#endregion
-                            return [2 /*return*/, result];
-                    }
-                });
-            });
+        async function base64toDbBinaryFormat(text) {
+            let result;
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            //#region @backend
+            result = await (async () => {
+                const buffer = await base64toBuffer(text);
+                return buffer;
+            })();
+            //#endregion
+            return result;
         }
         binary.base64toDbBinaryFormat = base64toDbBinaryFormat;
         //#endregion
         //#region binay utils / db binary format to base64 string
-        function dbBinaryFormatToBase64(binaryFormat) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var result;
-                var _this = this;
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, (function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var text;
-                                return tslib_1.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, bufferToBase64(binaryFormat)];
-                                        case 1:
-                                            text = _a.sent();
-                                            return [2 /*return*/, text];
-                                    }
-                                });
-                            }); })()];
-                        case 1:
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            //#region @backend
-                            result = _a.sent();
-                            //#endregion
-                            return [2 /*return*/, result];
-                    }
-                });
-            });
+        async function dbBinaryFormatToBase64(binaryFormat) {
+            let result;
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            //#region @backend
+            result = await (async () => {
+                const text = await bufferToBase64(binaryFormat);
+                return text;
+            })();
+            //#endregion
+            return result;
         }
         binary.dbBinaryFormatToBase64 = dbBinaryFormatToBase64;
         //#endregion
         //#region binay utils / base64 string to db binary format
-        function textToDbBinaryFormat(text) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var result;
-                var _this = this;
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, (function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var buffer;
-                                return tslib_1.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, textToBuffer(text)];
-                                        case 1:
-                                            buffer = _a.sent();
-                                            return [2 /*return*/, buffer];
-                                    }
-                                });
-                            }); })()];
-                        case 1:
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            //#region @backend
-                            result = _a.sent();
-                            //#endregion
-                            return [2 /*return*/, result];
-                    }
-                });
-            });
+        async function textToDbBinaryFormat(text) {
+            let result;
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            //#region @backend
+            result = await (async () => {
+                const buffer = await textToBuffer(text);
+                return buffer;
+            })();
+            //#endregion
+            return result;
         }
         binary.textToDbBinaryFormat = textToDbBinaryFormat;
         //#endregion
         //#region binay utils / db binary format to base64 string
-        function dbBinaryFormatToText(binaryFormat) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var result;
-                var _this = this;
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, (function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var text;
-                                return tslib_1.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, bufferToText(binaryFormat)];
-                                        case 1:
-                                            text = _a.sent();
-                                            return [2 /*return*/, text];
-                                    }
-                                });
-                            }); })()];
-                        case 1:
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            /* */
-                            //#region @backend
-                            result = _a.sent();
-                            //#endregion
-                            return [2 /*return*/, result];
-                    }
-                });
-            });
+        async function dbBinaryFormatToText(binaryFormat) {
+            let result;
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            //#region @backend
+            result = await (async () => {
+                const text = await bufferToText(binaryFormat);
+                return text;
+            })();
+            //#endregion
+            return result;
         }
         binary.dbBinaryFormatToText = dbBinaryFormatToText;
         //#endregion
         //#region binay utils / base64 string to nodejs buffer
         //#region @backend
-        function base64toBuffer(base64Data, contentTypeOverride) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var blob, buffer;
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, base64toBlob(base64Data, contentTypeOverride)];
-                        case 1:
-                            blob = _a.sent();
-                            return [4 /*yield*/, blobToBuffer(blob)];
-                        case 2:
-                            buffer = _a.sent();
-                            return [2 /*return*/, buffer];
-                    }
-                });
-            });
+        async function base64toBuffer(base64Data, contentTypeOverride) {
+            const blob = await base64toBlob(base64Data, contentTypeOverride);
+            const buffer = await blobToBuffer(blob);
+            return buffer;
         }
         binary.base64toBuffer = base64toBuffer;
         //#endregion
         //#endregion
         //#region binay utils / nodejs buffer to base64 string
         //#region @backend
-        function bufferToBase64(bufferData) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var blob, text;
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, bufferToBlob(bufferData)];
-                        case 1:
-                            blob = _a.sent();
-                            return [4 /*yield*/, blobToBase64(blob)];
-                        case 2:
-                            text = _a.sent();
-                            return [2 /*return*/, text];
-                    }
-                });
-            });
+        async function bufferToBase64(bufferData) {
+            const blob = await bufferToBlob(bufferData);
+            const text = await blobToBase64(blob);
+            return text;
         }
         binary.bufferToBase64 = bufferToBase64;
         //#endregion
         //#endregion
         //#region binay utils / file to blob
-        function fileToBlob(file) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var _a, _b;
-                return tslib_1.__generator(this, function (_c) {
-                    switch (_c.label) {
-                        case 0:
-                            _a = buffer_1.Blob.bind;
-                            _b = Uint8Array.bind;
-                            return [4 /*yield*/, file.arrayBuffer()];
-                        case 1: return [2 /*return*/, new (_a.apply(buffer_1.Blob, [void 0, [new (_b.apply(Uint8Array, [void 0, _c.sent()]))()], {
-                                    type: file.type,
-                                }]))()];
-                    }
-                });
+        async function fileToBlob(file) {
+            return new buffer_1.Blob([new Uint8Array(await file.arrayBuffer())], {
+                type: file.type,
             });
         }
         binary.fileToBlob = fileToBlob;
         //#endregion
         //#region binay utils / blob to file
-        function blobToFile(blob_1) {
-            return tslib_1.__awaiter(this, arguments, void 0, function (blob, nameForFile) {
-                if (nameForFile === void 0) { nameForFile = 'my-file-name'; }
-                return tslib_1.__generator(this, function (_a) {
-                    if (!nameForFile) {
-                        nameForFile = 'nonamefile' + new Date().getTime();
-                    }
-                    // @ts-ignore
-                    return [2 /*return*/, new File([blob], nameForFile)];
-                });
-            });
+        async function blobToFile(blob, nameForFile = 'my-file-name') {
+            if (!nameForFile) {
+                nameForFile = 'nonamefile' + new Date().getTime();
+            }
+            // @ts-ignore
+            return new File([blob], nameForFile);
         }
         binary.blobToFile = blobToFile;
         //#endregion
         //#region binay utils / nodejs blob to nodejs buffer
         //#region @backend
-        function blobToBuffer(blob) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var arrayBuffer, buffer;
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, blob.arrayBuffer()];
-                        case 1:
-                            arrayBuffer = _a.sent();
-                            buffer = Buffer.from(arrayBuffer);
-                            return [2 /*return*/, buffer];
-                    }
-                });
-            });
+        async function blobToBuffer(blob) {
+            const arrayBuffer = await blob.arrayBuffer();
+            const buffer = Buffer.from(arrayBuffer);
+            return buffer;
         }
         binary.blobToBuffer = blobToBuffer;
         //#endregion
         //#endregion
         //#region binay utils / nodejs buffer to nodejs blob
         //#region @backend
-        function bufferToBlob(buffer) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var blob;
-                return tslib_1.__generator(this, function (_a) {
-                    blob = new buffer_1.Blob([buffer]);
-                    return [2 /*return*/, blob];
-                });
-            });
+        async function bufferToBlob(buffer) {
+            const blob = new buffer_1.Blob([buffer]); // JavaScript Blob
+            return blob;
         }
         binary.bufferToBlob = bufferToBlob;
         //#endregion
         //#endregion
         //#region binay utils / text to nodejs buffer
         //#region @backend
-        function textToBuffer(text_1) {
-            return tslib_1.__awaiter(this, arguments, void 0, function (text, type) {
-                var blob, buffer;
-                if (type === void 0) { type = 'text/plain'; }
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, textToBlob(text, type)];
-                        case 1:
-                            blob = _a.sent();
-                            return [4 /*yield*/, blobToBuffer(blob)];
-                        case 2:
-                            buffer = _a.sent();
-                            return [2 /*return*/, buffer];
-                    }
-                });
-            });
+        async function textToBuffer(text, type = 'text/plain') {
+            const blob = await textToBlob(text, type);
+            const buffer = await blobToBuffer(blob);
+            return buffer;
         }
         binary.textToBuffer = textToBuffer;
         //#endregion
         //#endregion
         //#region binay utils / nodejs buffer to text
         //#region @backend
-        function bufferToText(buffer) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var blob, text;
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, bufferToBlob(buffer)];
-                        case 1:
-                            blob = _a.sent();
-                            return [4 /*yield*/, blobToText(blob)];
-                        case 2:
-                            text = _a.sent();
-                            return [2 /*return*/, text];
-                    }
-                });
-            });
+        async function bufferToText(buffer) {
+            const blob = await bufferToBlob(buffer);
+            const text = await blobToText(blob);
+            return text;
         }
         binary.bufferToText = bufferToText;
         //#endregion
         //#endregion
         //#region binay utils / text to blob
-        function textToBlob(text_1) {
-            return tslib_1.__awaiter(this, arguments, void 0, function (text, type) {
-                var blob;
-                if (type === void 0) { type = 'text/plain'; }
-                return tslib_1.__generator(this, function (_a) {
-                    blob = new buffer_1.Blob([text], { type: type });
-                    return [2 /*return*/, blob];
-                });
-            });
+        async function textToBlob(text, type = 'text/plain') {
+            const blob = new buffer_1.Blob([text], { type });
+            return blob;
         }
         binary.textToBlob = textToBlob;
         //#endregion
         //#region binay utils / blob to text
-        function blobToText(blob) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, blob.text()];
-                        case 1: return [2 /*return*/, _a.sent()];
-                    }
-                });
-            });
+        async function blobToText(blob) {
+            return await blob.text();
         }
         binary.blobToText = blobToText;
         //#endregion
         //#region binay utils / text to file
-        function textToFile(text, fileRelativePathOrName) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var ext, type, blob, file;
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            ext = core_imports_1.path.extname(fileRelativePathOrName);
-                            type = core_models_1.CoreModels.mimeTypes[ext];
-                            blob = new buffer_1.Blob([text], { type: type });
-                            return [4 /*yield*/, blobToFile(blob, fileRelativePathOrName)];
-                        case 1:
-                            file = _a.sent();
-                            // console.log({
-                            //   ext,
-                            //   blob, file
-                            // });
-                            // debugger
-                            return [2 /*return*/, file];
-                    }
-                });
-            });
+        async function textToFile(text, fileRelativePathOrName) {
+            // console.log({ path })
+            const ext = core_imports_1.path.extname(fileRelativePathOrName);
+            const type = core_models_1.CoreModels.mimeTypes[ext];
+            const blob = new buffer_1.Blob([text], { type });
+            const file = await blobToFile(blob, fileRelativePathOrName);
+            // console.log({
+            //   ext,
+            //   blob, file
+            // });
+            // debugger
+            return file;
         }
         binary.textToFile = textToFile;
         //#endregion
         //#region binay utils / file to text
-        function fileToText(file) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, file.text()];
-                        case 1: return [2 /*return*/, _a.sent()];
-                    }
-                });
-            });
+        async function fileToText(file) {
+            return await file.text();
         }
         binary.fileToText = fileToText;
         //#endregion
         //#region binay utils / json to blob
-        function jsonToBlob(jsonObj) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var blob;
-                return tslib_1.__generator(this, function (_a) {
-                    blob = new buffer_1.Blob([JSON.stringify(jsonObj, null, 2)], {
-                        type: 'application/json',
-                    });
-                    return [2 /*return*/, blob];
-                });
+        async function jsonToBlob(jsonObj) {
+            const blob = new buffer_1.Blob([JSON.stringify(jsonObj, null, 2)], {
+                type: 'application/json',
             });
+            return blob;
         }
         binary.jsonToBlob = jsonToBlob;
         //#endregion
@@ -728,45 +589,26 @@ var Utils;
         /**
          * TODO NOT TESTED
          */
-        function blobToJson(blob) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var _a, _b;
-                return tslib_1.__generator(this, function (_c) {
-                    switch (_c.label) {
-                        case 0:
-                            _b = (_a = JSON).parse;
-                            return [4 /*yield*/, blob.text()];
-                        case 1: return [2 /*return*/, _b.apply(_a, [_c.sent()])];
-                    }
-                });
-            });
+        async function blobToJson(blob) {
+            return JSON.parse(await blob.text());
         }
         binary.blobToJson = blobToJson;
         //#endregion
         //#region binay utils / get blob from url
-        function getBlobFrom(url) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var response;
-                return tslib_1.__generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, (0, axios_1.default)({
-                                url: url,
-                                method: 'get',
-                                responseType: 'blob',
-                            })];
-                        case 1:
-                            response = _a.sent();
-                            return [2 /*return*/, response.data];
-                    }
-                });
+        async function getBlobFrom(url) {
+            const response = await (0, axios_1.default)({
+                url,
+                method: 'get',
+                responseType: 'blob',
             });
+            return response.data;
         }
         binary.getBlobFrom = getBlobFrom;
         //#endregion
     })(binary = Utils.binary || (Utils.binary = {}));
     //#endregion
     //#region css
-    var css;
+    let css;
     (function (css) {
         //#region css utils / numeric value of pixels
         /**
@@ -775,9 +617,8 @@ var Utils;
          * @returns
          */
         function numValue(pixelsCss) {
-            var _a;
             // tslint:disable-next-line:radix
-            return parseInt((_a = pixelsCss === null || pixelsCss === void 0 ? void 0 : pixelsCss.toString()) === null || _a === void 0 ? void 0 : _a.replace('px', ''));
+            return parseInt(pixelsCss?.toString()?.replace('px', ''));
         }
         css.numValue = numValue;
         //#endregion
@@ -788,19 +629,229 @@ var Utils;
 //#region utils process
 var UtilsProcess;
 (function (UtilsProcess) {
-    var _this = this;
     //#endregion
     //#region utils process  / TODO start async
     /**
      * TODO IMPLEMENT
      * start async node process
      */
-    // export async function startAsync(
-    //   command: string,
-    //   options?: ProcessStartOptions,
-    // ) {
-    // TODO @LAST
-    // }
+    UtilsProcess.startAsync = async (command, cwd, 
+    // options?: ProcessStartOptions, // TODO change to this
+    options) => {
+        //#region @backendFunc
+        //#region preapre options
+        let { hideOutput, resolvePromiseMsg, outputLineReplace, prefix, extractFromLine, exitOnErrorCallback, askToTryAgainOnError, resolvePromiseMsgCallback, similarProcessKey, onChildProcessChange, outputBuffer, outputBufferMaxSize, } = options || {};
+        outputBufferMaxSize = outputBufferMaxSize || 1000;
+        command = index_1.Helpers._fixCommand(command);
+        const { stderr: stderResolvePromiseMsgCallback, stdout: stdoutResolvePromiseMsgCallback, exitCode: exitCodeResolvePromiseMsgCallback, } = resolvePromiseMsgCallback || {};
+        let childProcess;
+        // let {
+        //   stderMsgForPromiseResolve,
+        //   stdoutMsgForPromiseResolve
+        // } = resolvePromiseMsg || {};
+        // processes.push(proc);
+        if (!resolvePromiseMsg) {
+            resolvePromiseMsg = {};
+        }
+        if (!hideOutput) {
+            hideOutput = {};
+        }
+        let isResolved = false;
+        if (core_imports_1._.isString(resolvePromiseMsg.stdout)) {
+            resolvePromiseMsg.stdout = [resolvePromiseMsg.stdout];
+        }
+        if (core_imports_1._.isString(resolvePromiseMsg.stderr)) {
+            resolvePromiseMsg.stderr = [resolvePromiseMsg.stderr];
+        }
+        //#endregion
+        const handlProc = (proc) => {
+            return new Promise((resolve, reject) => {
+                // console.log(
+                //   `[execute] Process started...`,
+                //   (resolvePromiseMsg.stdout as string[]).map(c => `"${c}"`).join(','),
+                // );
+                //#region handle stdout data
+                proc.stdout.on('data', rawData => {
+                    let data = rawData?.toString() || '';
+                    data = index_1.Helpers.modifyLineByLine(data, // @ts-ignore
+                    outputLineReplace, prefix, extractFromLine);
+                    if (!core_imports_1._.isUndefined(outputBuffer)) {
+                        outputBuffer.push(data);
+                        if (outputBuffer.length > outputBufferMaxSize) {
+                            outputBuffer.shift();
+                        }
+                    }
+                    if (!hideOutput.stdout) {
+                        process.stdout.write(data);
+                    }
+                    if (core_imports_1._.isArray(resolvePromiseMsg.stdout)) {
+                        for (let index = 0; index < resolvePromiseMsg.stdout.length; index++) {
+                            // console.log(`DATA STDOUT: ${chalk.gray(data)}`);
+                            const resolveCompilationMessage = resolvePromiseMsg.stdout[index];
+                            if (data.search(resolveCompilationMessage) !== -1) {
+                                // Helpers.info(`[unitlOutputContains] AAA...`);
+                                stdoutResolvePromiseMsgCallback &&
+                                    stdoutResolvePromiseMsgCallback();
+                                if (!isResolved) {
+                                    isResolved = true;
+                                    resolve(void 0);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    // TODO NOT NEEDED
+                    if (core_imports_1._.isArray(resolvePromiseMsg.stderr)) {
+                        for (let index = 0; index < resolvePromiseMsg.stderr.length; index++) {
+                            const rejectm = resolvePromiseMsg.stderr[index];
+                            if (data.search(rejectm) !== -1) {
+                                // Helpers.info(`[unitlOutputContains] Rejected move to next step...`);
+                                stdoutResolvePromiseMsgCallback &&
+                                    stdoutResolvePromiseMsgCallback();
+                                if (!isResolved) {
+                                    isResolved = true;
+                                    reject();
+                                    proc.kill('SIGINT');
+                                }
+                                break;
+                            }
+                        }
+                    }
+                });
+                //#endregion
+                //#region handle exit process
+                proc.on('exit', async (code) => {
+                    // console.log(`Command exit code: ${code}`)
+                    if (hideOutput.acceptAllExitCodeAsSuccess) {
+                        exitCodeResolvePromiseMsgCallback &&
+                            exitCodeResolvePromiseMsgCallback(code);
+                        resolve(void 0);
+                    }
+                    else {
+                        if (code !== 0) {
+                            if (core_imports_1._.isFunction(exitOnErrorCallback)) {
+                                try {
+                                    await exitOnErrorCallback(code);
+                                    // await this.runSyncOrAsync({
+                                    //   functionFn: exitOnErrorCallback,
+                                    //   arrayOfParams: [code],
+                                    // });
+                                    reject(`Command failed with code=${code}`);
+                                }
+                                catch (error) {
+                                    reject(error);
+                                }
+                            }
+                            else {
+                                reject(`Command failed with code=${code}`);
+                            }
+                        }
+                        else {
+                            resolve(void 0);
+                        }
+                    }
+                });
+                //#endregion
+                //#region handle stdout error
+                proc.stdout.on('error', rawData => {
+                    let data = rawData?.toString() || '';
+                    data = index_1.Helpers.modifyLineByLine(data, // @ts-ignore
+                    outputLineReplace, prefix, extractFromLine);
+                    if (!core_imports_1._.isUndefined(outputBuffer)) {
+                        outputBuffer.push(data);
+                        if (outputBuffer.length > outputBufferMaxSize) {
+                            outputBuffer.shift();
+                        }
+                    }
+                    if (!hideOutput.stdout) {
+                        process.stdout.write(JSON.stringify(data));
+                    }
+                    // console.log(data);
+                });
+                //#endregion
+                //#region handle stder data
+                proc.stderr.on('data', rawData => {
+                    let data = rawData?.toString() || '';
+                    data = index_1.Helpers.modifyLineByLine(data, // @ts-ignore
+                    outputLineReplace, prefix, extractFromLine);
+                    if (!core_imports_1._.isUndefined(outputBuffer)) {
+                        outputBuffer.push(data);
+                        if (outputBuffer.length > outputBufferMaxSize) {
+                            outputBuffer.shift();
+                        }
+                    }
+                    if (!hideOutput.stderr) {
+                        process.stderr.write(data);
+                    }
+                    if (core_imports_1._.isArray(resolvePromiseMsg.stderr)) {
+                        // @ts-ignore
+                        for (let index = 0; index < resolvePromiseMsg.stderr.length; index++) {
+                            // @ts-ignore
+                            const rejectm = resolvePromiseMsg.stderr[index];
+                            if (data.search(rejectm) !== -1) {
+                                // Helpers.info(`[unitlOutputContains] Rejected move to next step...`);
+                                stderResolvePromiseMsgCallback &&
+                                    stderResolvePromiseMsgCallback();
+                                if (!isResolved) {
+                                    isResolved = true;
+                                    reject();
+                                    proc.kill('SIGINT');
+                                }
+                                break;
+                            }
+                        }
+                    }
+                });
+                //#endregion
+                //#region handle stder error
+                proc.stderr.on('error', rawData => {
+                    let data = rawData?.toString() || '';
+                    data = index_1.Helpers.modifyLineByLine(data, // @ts-ignore
+                    outputLineReplace, prefix, extractFromLine);
+                    if (!core_imports_1._.isUndefined(outputBuffer)) {
+                        outputBuffer.push(data);
+                        if (outputBuffer.length > outputBufferMaxSize) {
+                            outputBuffer.shift();
+                        }
+                    }
+                    // @ts-ignore
+                    if (!hideOutput.stderr) {
+                        process.stderr.write(JSON.stringify(data));
+                    }
+                    // console.log(data);
+                });
+                //#endregion
+            });
+        };
+        while (true) {
+            const maxBuffer = options?.biggerBuffer ? index_1.Helpers.bigMaxBuffer : void 0;
+            const env = { ...process.env, FORCE_COLOR: '1', NODE_ENV: 'development' };
+            childProcess = core_imports_3.child_process.exec(command, { cwd, env, maxBuffer });
+            onChildProcessChange && onChildProcessChange(childProcess);
+            try {
+                await handlProc(childProcess);
+                break;
+            }
+            catch (error) {
+                index_1.Helpers.error(`Command failed:
+
+${command}
+
+in location: ${cwd}
+
+        `, true, true);
+                if (askToTryAgainOnError) {
+                    if (!(await index_1.Helpers.questionYesNo(`Try again this command ?`))) {
+                        throw error;
+                    }
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        //#endregion
+    };
     //#endregion
     //#region utils process  / TODO start sync
     // /**
@@ -816,82 +867,75 @@ var UtilsProcess;
      * condition is met. It is useful for example when you want to start
      * process and wait until some output is in stdout or stderr.
      */
-    UtilsProcess.startAsyncChildProcessCommandUntil = function (command, options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var _a, stdout, stderr, resolveAfterAnyExitCode;
-        return tslib_1.__generator(this, function (_b) {
-            //#region @backendFunc
-            options = options || {};
-            _a = options.untilOptions || {}, stdout = _a.stdout, stderr = _a.stderr, resolveAfterAnyExitCode = _a.resolveAfterAnyExitCode;
-            options.cwd = options.cwd || process.cwd();
-            return [2 /*return*/, new Promise(function (resolve, reject) {
-                    var _a, _b;
-                    var childProc = core_imports_3.child_process.exec(command, {
-                        cwd: options.cwd,
-                        maxBuffer: index_1.Helpers.bigMaxBuffer,
-                    });
-                    var stdoutConditions = Array.isArray(stdout)
-                        ? stdout
-                        : stdout
-                            ? [stdout]
-                            : [];
-                    var stderrConditions = Array.isArray(stderr)
-                        ? stderr
-                        : stderr
-                            ? [stderr]
-                            : [];
-                    var checkConditions = function (output, conditions) {
-                        var conditionReady = conditions.some(function (condition) {
-                            return output.includes(condition);
-                        });
-                        // if(conditionReady){
-                        //   console.log('conditionReady MOVE ON', conditionReady);
-                        // }
-                        return conditionReady;
-                    };
-                    (_a = childProc.stdout) === null || _a === void 0 ? void 0 : _a.on('data', function (data) {
-                        var _a;
-                        if (options.displayOutputInParentProcess) {
-                            (_a = process.stdout) === null || _a === void 0 ? void 0 : _a.write(data);
-                        }
-                        if (checkConditions(data, stdoutConditions)) {
-                            resolve();
-                            childProc.kill();
-                        }
-                    });
-                    (_b = childProc.stderr) === null || _b === void 0 ? void 0 : _b.on('data', function (data) {
-                        var _a;
-                        if (options.displayOutputInParentProcess) {
-                            (_a = process.stderr) === null || _a === void 0 ? void 0 : _a.write(data);
-                        }
-                        if (checkConditions(data, stderrConditions)) {
-                            resolve();
-                            childProc.kill();
-                        }
-                    });
-                    childProc.on('close', function (exitCode) {
-                        if (resolveAfterAnyExitCode || exitCode === 0) {
-                            resolve();
-                        }
-                        else {
-                            reject(new Error("Process exited with code ".concat(exitCode)));
-                        }
-                    });
-                    childProc.on('error', function (error) {
-                        reject(error);
-                    });
-                })];
+    UtilsProcess.startAsyncChildProcessCommandUntil = async (command, options) => {
+        //#region @backendFunc
+        options = options || {};
+        const { stdout, stderr, resolveAfterAnyExitCode } = options.untilOptions || {};
+        options.cwd = options.cwd || process.cwd();
+        return new Promise((resolve, reject) => {
+            const childProc = core_imports_3.child_process.exec(command, {
+                cwd: options.cwd,
+                maxBuffer: index_1.Helpers.bigMaxBuffer,
+            });
+            const stdoutConditions = Array.isArray(stdout)
+                ? stdout
+                : stdout
+                    ? [stdout]
+                    : [];
+            const stderrConditions = Array.isArray(stderr)
+                ? stderr
+                : stderr
+                    ? [stderr]
+                    : [];
+            const checkConditions = (output, conditions) => {
+                const conditionReady = conditions.some(condition => output.includes(condition));
+                // if(conditionReady){
+                //   console.log('conditionReady MOVE ON', conditionReady);
+                // }
+                return conditionReady;
+            };
+            childProc.stdout?.on('data', data => {
+                if (options.displayOutputInParentProcess) {
+                    process.stdout?.write(data);
+                }
+                if (checkConditions(data, stdoutConditions)) {
+                    resolve();
+                    childProc.kill();
+                }
+            });
+            childProc.stderr?.on('data', data => {
+                if (options.displayOutputInParentProcess) {
+                    process.stderr?.write(data);
+                }
+                if (checkConditions(data, stderrConditions)) {
+                    resolve();
+                    childProc.kill();
+                }
+            });
+            childProc.on('close', exitCode => {
+                if (resolveAfterAnyExitCode || exitCode === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Process exited with code ${exitCode}`));
+                }
+            });
+            childProc.on('error', error => {
+                reject(error);
+            });
         });
-    }); };
+        //#endregion
+    };
     //#endregion
     //#region utils process  / get git bash path
-    UtilsProcess.getGitBashPath = function () {
+    UtilsProcess.getGitBashPath = () => {
         //#region @backendFunc
         if (process.platform !== 'win32') {
             return null;
         }
         try {
             // Execute the 'where' command to find bash.exe
-            var gitBashPath = core_imports_3.child_process
+            const gitBashPath = core_imports_3.child_process
                 .execSync('where bash.exe', { encoding: 'utf8' })
                 .split('\n')[0]
                 .trim();
@@ -911,53 +955,58 @@ var UtilsProcess;
      * TODO IMPLEMENT
      * start async node process
      */
-    UtilsProcess.startInNewTerminalWindow = function (command, options) {
-        var e_3, _a;
+    UtilsProcess.startInNewTerminalWindow = (command, options) => {
         //#region @backendFunc
-        var platform = process.platform;
+        const platform = process.platform;
         options = options || {};
         options.cwd = options.cwd || process.cwd();
         if (platform === 'win32') {
-            var gitBashPath = UtilsProcess.getGitBashPath();
+            const gitBashPath = UtilsProcess.getGitBashPath();
             // const currentBash = getBashOrShellName();
             // console.log('gitBashPath', gitBashPath);
             // console.log('currentBash', currentBash);
             if (gitBashPath) {
-                return (0, core_imports_3.spawn)('start bash', ['-c', "".concat(command)], // Use '-c' to execute a single command in Git Bash
+                return (0, core_imports_3.spawn)('start bash', ['-c', `${command}`], // Use '-c' to execute a single command in Git Bash
                 {
                     detached: true, // Detached process
                     stdio: 'ignore', // Ignore stdio
-                    cwd: options === null || options === void 0 ? void 0 : options.cwd,
+                    cwd: options?.cwd,
                 }).unref(); // Ensure the parent process can exit independently
             }
-            console.error("\n\n\n        Please install git bash to use this cli (https://gitforwindows.org/)\n\n\n        ");
+            console.error(`
+
+
+        Please install git bash to use this cli (https://gitforwindows.org/)
+
+
+        `);
             // For Windows
-            return (0, core_imports_3.spawn)('cmd', ['/c', 'start', 'cmd', '/k', "".concat(command)], {
+            return (0, core_imports_3.spawn)('cmd', ['/c', 'start', 'cmd', '/k', `${command}`], {
                 detached: true,
                 stdio: 'ignore',
-                cwd: options === null || options === void 0 ? void 0 : options.cwd,
+                cwd: options?.cwd,
             }).unref();
         }
         else if (platform === 'darwin') {
             // For macOS
-            return (0, core_imports_3.spawn)('osascript', ['-e', "tell application \"Terminal\" to do script \"".concat(command, "\"")], {
+            return (0, core_imports_3.spawn)('osascript', ['-e', `tell application "Terminal" to do script "${command}"`], {
                 detached: true,
                 stdio: 'ignore',
-                cwd: options === null || options === void 0 ? void 0 : options.cwd,
+                cwd: options?.cwd,
             }).unref();
         }
         else if (platform === 'linux') {
             if (!UtilsOs.isRunningInLinuxGraphicsCapableEnvironment()) {
-                var child_1 = core_imports_3.child_process.spawn(command, {
+                const child = core_imports_3.child_process.spawn(command, {
                     detached: true,
-                    cwd: options === null || options === void 0 ? void 0 : options.cwd,
+                    cwd: options?.cwd,
                     stdio: 'ignore',
                 });
-                child_1.unref();
+                child.unref();
                 return;
             }
             // For Linux (gnome-terminal as an example)
-            var terminals = [
+            const terminals = [
                 { cmd: 'gnome-terminal', args: ['--', 'bash', '-c'] }, // GNOME Terminal
                 { cmd: 'konsole', args: ['-e', 'bash', '-c'] }, // Konsole
                 { cmd: 'xfce4-terminal', args: ['-e', 'bash', '-c'] }, // XFCE4 Terminal
@@ -969,55 +1018,45 @@ var UtilsProcess;
                 { cmd: 'alacritty', args: ['-e', 'bash', '-c'] }, // Alacritty
                 { cmd: 'urxvt', args: ['-e', 'bash', '-c'] }, // URxvt
             ];
-            var terminalCommand = '';
-            var terminalArgs = [];
-            try {
-                for (var terminals_1 = tslib_1.__values(terminals), terminals_1_1 = terminals_1.next(); !terminals_1_1.done; terminals_1_1 = terminals_1.next()) {
-                    var term = terminals_1_1.value;
-                    try {
-                        core_imports_3.child_process.execSync("which ".concat(term.cmd), {
-                            stdio: 'ignore',
-                            cwd: options === null || options === void 0 ? void 0 : options.cwd,
-                        });
-                        terminalCommand = term.cmd;
-                        terminalArgs = tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(term.args), false), [command], false);
-                        break;
-                    }
-                    catch (err) {
-                        // Terminal not found, continue to the next
-                    }
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
+            let terminalCommand = '';
+            let terminalArgs = [];
+            for (const term of terminals) {
                 try {
-                    if (terminals_1_1 && !terminals_1_1.done && (_a = terminals_1.return)) _a.call(terminals_1);
+                    core_imports_3.child_process.execSync(`which ${term.cmd}`, {
+                        stdio: 'ignore',
+                        cwd: options?.cwd,
+                    });
+                    terminalCommand = term.cmd;
+                    terminalArgs = [...term.args, command];
+                    break;
+                }
+                catch (err) {
+                    // Terminal not found, continue to the next
                 }
-                finally { if (e_3) throw e_3.error; }
             }
             if (!terminalCommand) {
                 console.error('No supported terminal emulator found.');
                 return;
             }
-            var child = (0, core_imports_3.spawn)(terminalCommand, terminalArgs, {
+            const child = (0, core_imports_3.spawn)(terminalCommand, terminalArgs, {
                 detached: true,
                 stdio: 'ignore',
             });
             child.unref();
         }
         else {
-            index_1.Helpers.throw("Unsupported platform: ".concat(platform));
+            index_1.Helpers.throw(`Unsupported platform: ${platform}`);
         }
         //#endregion
     };
     //#endregion
     //#region utils process / get bash or shell name
-    UtilsProcess.getBashOrShellName = function () {
+    UtilsProcess.getBashOrShellName = () => {
         /* */
         /* */
         //#region @backendFunc
-        var platform = process.platform; // Identify the platform: 'win32', 'darwin', 'linux'
-        var shell = process.env.SHELL || process.env.ComSpec || ''; // Common shell environment variables
+        const platform = process.platform; // Identify the platform: 'win32', 'darwin', 'linux'
+        const shell = process.env.SHELL || process.env.ComSpec || ''; // Common shell environment variables
         if (platform === 'win32') {
             if (shell.includes('cmd.exe'))
                 return 'cmd';
@@ -1049,19 +1088,133 @@ var UtilsProcess;
         //#endregion
     };
     //#endregion
+    /**
+     * Get CPU and memory usage for a single PID.
+     */
+    UtilsProcess.getUsageForPid = async (pid) => {
+        //#region @backendFunc
+        // pidusage returns cpu usage as a percentage (e.g., 10.0 for ~10%)
+        // memory usage is returned in bytes.
+        try {
+            var pidusage = require('pidusage');
+            const stat = await pidusage(pid);
+            const memoryInMB = stat.memory / (1024 * 1024);
+            const memoryInGB = stat.memory / (1024 * 1024 * 1024);
+            return {
+                cpu: stat.cpu, // CPU usage (percent)
+                memoryInMB,
+                memoryInGB,
+            };
+        }
+        catch (error) {
+            return {
+                cpu: NaN, // CPU usage (percent)
+                memoryInMB: NaN, // Memory usage (bytes)
+                memoryInGB: NaN, // Memory usage
+            };
+        }
+        //#endregion
+    };
+    /**
+     * Return a list of direct child PIDs for the given PID on a Unix-like system.
+     * Uses `ps -o pid= --ppid <pid>` to find child processes.
+     */
+    async function getChildPidsUnix(pid) {
+        //#region @backendFunc
+        const cmd = `ps -o pid= --ppid ${pid}`;
+        try {
+            const execAsync = (0, util_1.promisify)(core_imports_3.child_process.exec);
+            const { stdout } = await execAsync(cmd);
+            // Each line should contain just the PID
+            return stdout
+                .split('\n')
+                .map(line => line.trim())
+                .filter(line => line !== '')
+                .map(line => Number(line))
+                .filter(n => !isNaN(n));
+        }
+        catch {
+            return [];
+        }
+        //#endregion
+    }
+    /**
+     * Return a list of direct child PIDs for the given PID on Windows.
+     * Uses `wmic process where (ParentProcessId=<pid>) get ProcessId` to find child processes.
+     */
+    async function getChildPidsWindows(pid) {
+        //#region @backendFunc
+        const cmd = `wmic process where (ParentProcessId=${pid}) get ProcessId`;
+        try {
+            const execAsync = (0, util_1.promisify)(core_imports_3.child_process.exec);
+            const { stdout } = await execAsync(cmd);
+            // The output generally has lines, including one that says "ProcessId" and then the PIDs
+            // We'll parse out any numeric lines
+            return stdout
+                .split('\n')
+                .map(line => line.trim())
+                .filter(line => /^\d+$/.test(line)) // only keep pure digits
+                .map(line => Number(line))
+                .filter(n => !isNaN(n));
+        }
+        catch {
+            return [];
+        }
+        //#endregion
+    }
+    /**
+     * Cross-platform function to list *direct* child PIDs of a given PID.
+     * Uses the appropriate command depending on `process.platform`.
+     */
+    async function getChildPidsOnce(pid) {
+        //#region @backendFunc
+        if (process.platform === 'win32') {
+            return getChildPidsWindows(pid);
+        }
+        else {
+            return getChildPidsUnix(pid);
+        }
+        //#endregion
+    }
+    UtilsProcess.getChildPidsOnce = getChildPidsOnce;
+    /**
+     * Get CPU and memory usage for the current process (the Node.js process itself),
+     * plus any child processes spawned by it.
+     */
+    UtilsProcess.getCurrentProcessAndChildUsage = async () => {
+        //#region @backendFunc
+        const currentPid = process.pid;
+        // Get stats for current Node.js process
+        const currentUsage = await UtilsProcess.getUsageForPid(currentPid);
+        // Get list of child PIDs
+        const childPids = await getChildPidsOnce(currentPid);
+        // Gather usage for each child
+        const childrenUsage = await Promise.all(childPids.map(async (pid) => {
+            const usage = await UtilsProcess.getUsageForPid(pid);
+            return {
+                pid,
+                cpu: usage.cpu,
+                memoryInMB: usage.memoryInMB,
+            };
+        }));
+        return {
+            current: currentUsage,
+            children: childrenUsage,
+        };
+        //#endregion
+    };
 })(UtilsProcess || (exports.UtilsProcess = UtilsProcess = {}));
 //#endregion
 //#region utils os
 var UtilsOs;
 (function (UtilsOs) {
-    var _this = this;
     //#region utils os / is running in browser
     /**
      * check if script is running in client browser
      * (websql model -> is also considered as browser
      * because it is running in browser)
      */
-    UtilsOs.isRunningInBrowser = function () {
+    UtilsOs.isRunningInBrowser = () => {
         //#region @backend
         return false;
         //#endregion
@@ -1073,7 +1226,7 @@ var UtilsOs;
      * check if script is running in nodejs
      * (backend script or electron script)
      */
-    UtilsOs.isRunningInNode = function () {
+    UtilsOs.isRunningInNode = () => {
         //#region @backend
         return true;
         //#endregion
@@ -1086,7 +1239,7 @@ var UtilsOs;
      * browser mode that has sql.js backend
      * and executes sql queries in browser
      */
-    UtilsOs.isRunningInWebSQL = function () {
+    UtilsOs.isRunningInWebSQL = () => {
         //#region @backend
         return false;
         //#endregion
@@ -1100,7 +1253,7 @@ var UtilsOs;
      * check whether the current process is running inside
      * Electron backend or browser.
      */
-    UtilsOs.isRunningInElectron = function () {
+    UtilsOs.isRunningInElectron = () => {
         // Renderer process
         // @ts-ignore
         if (typeof window !== 'undefined' &&
@@ -1124,12 +1277,30 @@ var UtilsOs;
         return false;
     };
     //#endregion
+    //#region utils os / is running in vscode extension
+    /**
+     * Check whether the current process is running inside
+     * a Visual Studio Code extension.
+     */
+    UtilsOs.isRunningInVscodeExtension = () => {
+        //#region @backendFunc
+        try {
+            const vscode = require('vscode');
+            return !!vscode;
+        }
+        catch (error) {
+            return false;
+        }
+        // return !!process.env.VSCODE_PID || process.execPath.includes('Code');
+        //#endregion
+    };
+    //#endregion
     //#region utils os / is running in wsl
     /**
      * Check wether the current process is running inside
      * windows subsystem for linux (WSL).
      */
-    UtilsOs.isRunningInWsl = function () {
+    UtilsOs.isRunningInWsl = () => {
         /* */
         /* */
         //#region @backendFunc
@@ -1151,13 +1322,23 @@ var UtilsOs;
         //#endregion
     };
     //#endregion
+    //#region utils os / is running in windows cmd
+    UtilsOs.isRunningInWindowsCmd = () => {
+        /* */
+        /* */
+        //#region @backendFunc
+        const shell = process.env.ComSpec || process.env.SHELL;
+        return shell && shell.toLowerCase().includes('cmd.exe');
+        //#endregion
+    };
+    //#endregion
     //#region utils os / is running in docker
-    UtilsOs.isRunningInDocker = function () {
+    UtilsOs.isRunningInDocker = () => {
         /* */
         /* */
         //#region @backendFunc
         try {
-            var cgroup = core_imports_4.fse.readFileSync('/proc/1/cgroup', 'utf8');
+            const cgroup = core_imports_4.fse.readFileSync('/proc/1/cgroup', 'utf8');
             return /docker|kubepods|containerd/.test(cgroup);
         }
         catch (e) {
@@ -1167,7 +1348,7 @@ var UtilsOs;
     };
     //#endregion
     //#region utils os / is running in linux graphics capable environment
-    UtilsOs.isRunningInLinuxGraphicsCapableEnvironment = function () {
+    UtilsOs.isRunningInLinuxGraphicsCapableEnvironment = () => {
         //#region @backendFunc
         if (core_imports_1.os.platform() !== 'linux') {
             return false;
@@ -1181,7 +1362,7 @@ var UtilsOs;
     /**
      * Check whether the current process is running in CLI mode.
      */
-    UtilsOs.isRunningInCliMode = function () {
+    UtilsOs.isRunningInCliMode = () => {
         /* */
         /* */
         //#region @backendFunc
@@ -1193,7 +1374,7 @@ var UtilsOs;
     /**
      * Check whether the current process is running in mocha test.
      */
-    UtilsOs.isRunningInMochaTest = function () {
+    UtilsOs.isRunningInMochaTest = () => {
         /* */
         /* */
         //#region @backendFunc
@@ -1202,33 +1383,29 @@ var UtilsOs;
     };
     //#endregion
     //#region utils os / is port in use
-    var isPortInUseOnHost = function (port, host) {
+    const isPortInUseOnHost = (port, host) => {
         //#region @backendFunc
-        return new Promise(function (resolve, reject) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var server;
-            return tslib_1.__generator(this, function (_a) {
-                server = net.createServer();
-                // If the port is already in use, you'll get an EADDRINUSE error.
-                server.once('error', function (err) {
-                    // console.log('error', err);
-                    if (err.code === 'EADDRINUSE' || err.code === 'EACCES') {
-                        resolve(true); // Port is in use
-                    }
-                    else {
-                        reject(err); // Some other error occurred
-                    }
-                });
-                // If the server successfully starts listening, the port is free.
-                server.once('listening', function () {
-                    server.close(function () {
-                        // console.log(`closing ${port} on ${host}`);
-                        resolve(false); // Port is not in use
-                    });
+        return new Promise(async (resolve, reject) => {
+            const server = net.createServer();
+            // If the port is already in use, you'll get an EADDRINUSE error.
+            server.once('error', (err) => {
+                // console.log('error', err);
+                if (err.code === 'EADDRINUSE' || err.code === 'EACCES') {
+                    resolve(true); // Port is in use
+                }
+                else {
+                    reject(err); // Some other error occurred
+                }
+            });
+            // If the server successfully starts listening, the port is free.
+            server.once('listening', () => {
+                server.close(() => {
+                    // console.log(`closing ${port} on ${host}`);
+                    resolve(false); // Port is not in use
                 });
-                server.listen(port, host);
-                return [2 /*return*/];
             });
-        }); });
+            server.listen(port, host);
+        });
         //#endregion
     };
     /**
@@ -1238,49 +1415,21 @@ var UtilsOs;
      * @param host - The hostname or IP address to bind to (default: '127.0.0.1').
      * @returns Promise<boolean> - Resolves to `true` if the port is in use, otherwise `false`.
      */
-    UtilsOs.isPortInUse = function (port, options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var hostArr, hostArr_1, hostArr_1_1, host, e_4_1;
-        var e_4, _a;
-        return tslib_1.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    //#region @backendFunc
-                    options = options || {};
-                    hostArr = options.checkForSpecificOnlyHost
-                        ? [options.checkForSpecificOnlyHost]
-                        : ['::', '::1', '0.0.0.0', '127.0.0.1', 'localhost'];
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 6, 7, 8]);
-                    hostArr_1 = tslib_1.__values(hostArr), hostArr_1_1 = hostArr_1.next();
-                    _b.label = 2;
-                case 2:
-                    if (!!hostArr_1_1.done) return [3 /*break*/, 5];
-                    host = hostArr_1_1.value;
-                    return [4 /*yield*/, isPortInUseOnHost(port, host)];
-                case 3:
-                    if (_b.sent()) {
-                        return [2 /*return*/, true];
-                    }
-                    _b.label = 4;
-                case 4:
-                    hostArr_1_1 = hostArr_1.next();
-                    return [3 /*break*/, 2];
-                case 5: return [3 /*break*/, 8];
-                case 6:
-                    e_4_1 = _b.sent();
-                    e_4 = { error: e_4_1 };
-                    return [3 /*break*/, 8];
-                case 7:
-                    try {
-                        if (hostArr_1_1 && !hostArr_1_1.done && (_a = hostArr_1.return)) _a.call(hostArr_1);
-                    }
-                    finally { if (e_4) throw e_4.error; }
-                    return [7 /*endfinally*/];
-                case 8: return [2 /*return*/, false];
+    UtilsOs.isPortInUse = async (port, options) => {
+        //#region @backendFunc
+        options = options || {};
+        const hostArr = options.checkForSpecificOnlyHost
+            ? [options.checkForSpecificOnlyHost]
+            : ['::', '::1', '0.0.0.0', '127.0.0.1', 'localhost'];
+        // console.log({ hostArr });
+        for (const host of hostArr) {
+            if (await isPortInUseOnHost(port, host)) {
+                return true;
             }
-        });
-    }); };
+        }
+        return false;
+        //#endregion
+    };
     //#endregion
 })(UtilsOs || (exports.UtilsOs = UtilsOs = {}));
 //#endregion
@@ -1288,7 +1437,7 @@ var UtilsOs;
 var UtilsString;
 (function (UtilsString) {
     //#region utils string / kebab case no split numbers
-    UtilsString.kebabCaseNoSplitNumbers = function (input) {
+    UtilsString.kebabCaseNoSplitNumbers = (input) => {
         return (input
             // Match spaces or any kind of whitespace and replace with a hyphen
             .replace(/\s+/g, '-')
@@ -1306,31 +1455,31 @@ var UtilsString;
  */
 var UtilsMigrations;
 (function (UtilsMigrations) {
-    UtilsMigrations.getTimestampFromClassName = function (className) {
-        var _a = tslib_1.__read(className.split('_') || [], 2), maybeTimestamp1 = _a[0], maybeTimestamp2 = _a[1];
+    UtilsMigrations.getTimestampFromClassName = (className) => {
+        const [maybeTimestamp1, maybeTimestamp2] = className.split('_') || [];
         // console.log({ maybeTimestamp1, maybeTimestamp2 });
-        var timestamp1 = parseInt(maybeTimestamp1);
-        var timestamp2 = parseInt(maybeTimestamp2);
-        var timestamp = !core_imports_1._.isNaN(timestamp1) ? timestamp1 : timestamp2;
+        const timestamp1 = parseInt(maybeTimestamp1);
+        const timestamp2 = parseInt(maybeTimestamp2);
+        const timestamp = !core_imports_1._.isNaN(timestamp1) ? timestamp1 : timestamp2;
         return UtilsMigrations.isValidTimestamp(timestamp) ? timestamp : void 0;
     };
-    UtilsMigrations.getFormattedTimestampFromClassName = function (className) {
-        var timestamp = UtilsMigrations.getTimestampFromClassName(className);
+    UtilsMigrations.getFormattedTimestampFromClassName = (className) => {
+        const timestamp = UtilsMigrations.getTimestampFromClassName(className);
         if (!timestamp) {
             return void 0;
         }
         return UtilsMigrations.formatTimestamp(timestamp);
     };
-    UtilsMigrations.formatTimestamp = function (timestamp) {
-        var dateFromTimestamp = new Date(timestamp);
-        return "".concat((0, core_imports_2.dateformat)(dateFromTimestamp, 'dd-mm-yyyy HH:MM:ss'));
+    UtilsMigrations.formatTimestamp = (timestamp) => {
+        const dateFromTimestamp = new Date(timestamp);
+        return `${(0, core_imports_2.dateformat)(dateFromTimestamp, 'dd-mm-yyyy HH:MM:ss')}`;
     };
-    UtilsMigrations.isValidTimestamp = function (value) {
+    UtilsMigrations.isValidTimestamp = (value) => {
         if (typeof value !== 'number') {
             return false; // Must be a number
         }
-        var minTimestamp = 0; // Minimum possible timestamp (Unix epoch)
-        var maxTimestamp = 8640000000000000; // Max safe timestamp in JS (represents year ~275760)
+        const minTimestamp = 0; // Minimum possible timestamp (Unix epoch)
+        const maxTimestamp = 8640000000000000; // Max safe timestamp in JS (represents year ~275760)
         return value >= minTimestamp && value <= maxTimestamp;
     };
 })(UtilsMigrations || (exports.UtilsMigrations = UtilsMigrations = {}));
@@ -1338,10 +1487,18 @@ var UtilsMigrations;
 //#region utils terminal
 var UtilsTerminal;
 (function (UtilsTerminal) {
-    var _this = this;
+    //#endregion
+    //#region wait
+    UtilsTerminal.wait = (second) => {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                resolve(void 0);
+            }, second * 1000);
+        });
+    };
     //#endregion
     //#region clear
-    UtilsTerminal.clearConsole = function () {
+    UtilsTerminal.clearConsole = () => {
         //#region @backendFunc
         index_1.Helpers.msgCacheClear();
         console.log('\x1Bc');
@@ -1355,422 +1512,387 @@ var UtilsTerminal;
     };
     //#endregion
     //#region transform choices
-    var transformChoices = function (choices) {
+    const transformChoices = (choices) => {
         //#region @backendFunc
         if (!core_imports_1._.isArray(choices) && core_imports_1._.isObject(choices)) {
             choices = Object.keys(choices)
-                .map(function (key) {
+                .map(key => {
                 return {
                     name: choices[key].name,
                     value: key,
                 };
             })
-                .reduce(function (a, b) { return a.concat(b); }, []);
+                .reduce((a, b) => a.concat(b), []);
         }
-        return choices.map(function (c) { return ({ name: c.name, value: c.value }); });
+        return choices.map(c => ({ name: c.name, value: c.value }));
         //#endregion
     };
     //#endregion
     //#region multiselect
-    UtilsTerminal.multiselect = function (options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var select, fuzzy, choices, defaultValue, res;
-        return tslib_1.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return require('inquirer-select-pro'); })];
-                case 1:
-                    select = (_a.sent()).select;
-                    return [4 /*yield*/, Promise.resolve().then(function () { return require('fuzzy'); })];
-                case 2:
-                    fuzzy = _a.sent();
-                    options = core_imports_1._.cloneDeep(options);
-                    options.autocomplete = core_imports_1._.isNil(options.autocomplete)
-                        ? true
-                        : options.autocomplete;
-                    choices = transformChoices(options.choices);
-                    if (!(Object.keys(choices || {}).length === 0)) return [3 /*break*/, 4];
-                    return [4 /*yield*/, UtilsTerminal.pressAnyKeyToContinueAsync({
-                            message: 'No choices available. Press any key to continue...',
-                        })];
-                case 3:
-                    _a.sent();
-                    return [2 /*return*/, []];
-                case 4:
-                    defaultValue = options.defaultSelected || [];
-                    return [4 /*yield*/, select({
-                            message: options.question,
-                            // options: choices,
-                            clearInputWhenSelected: true,
-                            emptyText: '<< No results >>',
-                            multiple: !options.onlyOneChoice,
-                            canToggleAll: true,
-                            pageSize: 10,
-                            loop: true,
-                            defaultValue: defaultValue,
-                            options: !options.autocomplete
-                                ? choices
-                                : function (input) {
-                                    if (input === void 0) { input = ''; }
-                                    if (!input) {
-                                        return choices;
-                                    }
-                                    var fuzzyResult = fuzzy.filter(input, choices.map(function (f) { return f.name; }));
-                                    return fuzzyResult.map(function (el) {
-                                        return {
-                                            name: el.original,
-                                            value: choices.find(function (c) { return c.name === el.original; }).value,
-                                        };
-                                    });
-                                },
-                        })];
-                case 5:
-                    res = _a.sent();
-                    return [2 /*return*/, (Array.isArray(res) ? res : [res])];
-            }
+    UtilsTerminal.multiselect = async (options) => {
+        //#region @backendFunc
+        const { select } = await Promise.resolve().then(() => require('inquirer-select-pro'));
+        const fuzzy = await Promise.resolve().then(() => require('fuzzy'));
+        options = core_imports_1._.cloneDeep(options);
+        options.autocomplete = core_imports_1._.isNil(options.autocomplete)
+            ? true
+            : options.autocomplete;
+        const choices = transformChoices(options.choices);
+        if (Object.keys(choices || {}).length === 0) {
+            await UtilsTerminal.pressAnyKeyToContinueAsync({
+                message: 'No choices available. Press any key to continue...',
+            });
+            return [];
+        }
+        const defaultValue = options.defaultSelected || [];
+        // console.log({ defaultValue, choices });
+        const res = await select({
+            message: options.question,
+            // options: choices,
+            clearInputWhenSelected: true,
+            emptyText: '<< No results >>',
+            multiple: !options.onlyOneChoice,
+            canToggleAll: true,
+            pageSize: 10,
+            loop: true,
+            defaultValue,
+            options: !options.autocomplete
+                ? choices
+                : (input = '') => {
+                    if (!input) {
+                        return choices;
+                    }
+                    const fuzzyResult = fuzzy.filter(input, choices.map(f => f.name));
+                    return fuzzyResult.map(el => {
+                        return {
+                            name: el.original,
+                            value: choices.find(c => c.name === el.original).value,
+                        };
+                    });
+                },
         });
-    }); };
+        return (Array.isArray(res) ? res : [res]);
+        //#region old autocomplete
+        // const prompt = new AutoComplete({
+        //   name: 'value',
+        //   message: question,
+        //   limit: 10,
+        //   multiple: true,
+        //   choices,
+        //   initial: (selected || []).map(s => s.name),
+        //   // selected,
+        //   hint: '- Space to select. Return to submit',
+        //   footer() {
+        //     return CLI.chalk.green('(Scroll up and down to reveal more choices)');
+        //   },
+        //   result(names) {
+        //     return _.values(this.map(names)) || [];
+        //   },
+        // });
+        // const res = await prompt.run();
+        //#endregion
+        //#region old inquirer
+        // const res = (await inquirer.prompt({
+        //   type: 'checkbox',
+        //   name: 'value',
+        //   message: question,
+        //   default: selected.map(s => s.name),
+        //   choices,
+        //   pageSize: 10,
+        //   loop: false,
+        // } as any)) as any;
+        // return res.value;
+        //#endregion
+        //#endregion
+    };
     //#endregion
     //#region select and execute
     /**
      * Similar to select but executes action if provided
      * @returns selected and executed value
      */
-    UtilsTerminal.multiselectActionAndExecute = function (choices, options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var res, actionResults, _a, _b, _c, _i, key, _d, _e;
-        return tslib_1.__generator(this, function (_f) {
-            switch (_f.label) {
-                case 0:
-                    //#region @backendFunc
-                    options = options || {};
-                    options.question = options.question || 'Select actions to execute';
-                    options.executeActionsOnDefault = core_imports_1._.isBoolean(options.executeActionsOnDefault)
-                        ? options.executeActionsOnDefault
-                        : true;
-                    return [4 /*yield*/, UtilsTerminal.multiselect(tslib_1.__assign(tslib_1.__assign({}, options), { choices: choices }))];
-                case 1:
-                    res = _f.sent();
-                    actionResults = [];
-                    if (!options.executeActionsOnDefault) return [3 /*break*/, 5];
-                    _a = res;
-                    _b = [];
-                    for (_c in _a)
-                        _b.push(_c);
-                    _i = 0;
-                    _f.label = 2;
-                case 2:
-                    if (!(_i < _b.length)) return [3 /*break*/, 5];
-                    _c = _b[_i];
-                    if (!(_c in _a)) return [3 /*break*/, 4];
-                    key = _c;
-                    if (!(res[key] && choices[key] && core_imports_1._.isFunction(choices[key].action))) return [3 /*break*/, 4];
-                    _e = (_d = actionResults).push;
-                    return [4 /*yield*/, choices[key].action()];
-                case 3:
-                    _e.apply(_d, [_f.sent()]);
-                    _f.label = 4;
-                case 4:
-                    _i++;
-                    return [3 /*break*/, 2];
-                case 5: 
-                // console.log(`Response from select: "${res}"`);
-                // pipeEnterToStdin();
-                return [2 /*return*/, {
-                        selected: res,
-                        actionResults: actionResults,
-                        /**
-                         * object containing all selected actions
-                         */
-                        actions: res.map(function (r) { return choices[r].action; }),
-                    }];
-            }
+    UtilsTerminal.multiselectActionAndExecute = async (choices, options) => {
+        //#region @backendFunc
+        options = options || {};
+        options.question = options.question || 'Select actions to execute';
+        options.executeActionsOnDefault = core_imports_1._.isBoolean(options.executeActionsOnDefault)
+            ? options.executeActionsOnDefault
+            : true;
+        // if (Object.keys(choices || {}).length === 0) {
+        //   await UtilsTerminal.pressAnyKeyToContinueAsync({
+        //     message: 'No choices available. Press any key to continue...',
+        //   });
+        //   return { selected: [] as (keyof CHOICE)[], action: async () => void 0 };
+        // }
+        const res = await UtilsTerminal.multiselect({
+            ...options,
+            choices,
         });
-    }); };
+        // clearConsole();
+        let actionResults = [];
+        if (options.executeActionsOnDefault) {
+            for (const key in res) {
+                if (res[key] && choices[key] && core_imports_1._.isFunction(choices[key].action)) {
+                    actionResults.push(await choices[key].action());
+                }
+            }
+        }
+        // console.log(`Response from select: "${res}"`);
+        // pipeEnterToStdin();
+        return {
+            selected: res,
+            actionResults,
+            /**
+             * object containing all selected actions
+             */
+            actions: res.map(r => choices[r].action),
+        };
+        //#endregion
+    };
     //#endregion
     //#region select and execute
     /**
      * Similar to select but executes action if provided
      * @returns selected and executed value
      */
-    UtilsTerminal.selectActionAndExecute = function (choices, options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var res, actionResult;
-        var _this = this;
-        return tslib_1.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    //#region @backendFunc
-                    options = options || {};
-                    options.question = options.question || 'Select action to execute';
-                    options.executeActionOnDefault = core_imports_1._.isBoolean(options.executeActionOnDefault)
-                        ? options.executeActionOnDefault
-                        : true;
-                    if (!(Object.keys(choices || {}).length === 0)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, UtilsTerminal.pressAnyKeyToContinueAsync({
-                            message: 'No choices available. Press any key to continue...',
-                        })];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/, { selected: void 0, action: function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-                                return [2 /*return*/, void 0];
-                            }); }); } }];
-                case 2: return [4 /*yield*/, UtilsTerminal.select(tslib_1.__assign(tslib_1.__assign({}, options), { choices: choices }))];
-                case 3:
-                    res = _a.sent();
-                    if (!(res &&
-                        choices[res] &&
-                        core_imports_1._.isFunction(choices[res].action) &&
-                        options.executeActionOnDefault)) return [3 /*break*/, 5];
-                    return [4 /*yield*/, choices[res].action()];
-                case 4:
-                    actionResult = _a.sent();
-                    _a.label = 5;
-                case 5: 
-                // console.log(`Response from select: "${res}"`);
-                // pipeEnterToStdin();
-                return [2 /*return*/, {
-                        selected: res,
-                        actionResult: actionResult,
-                        action: function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, choices[res].action()];
-                                case 1: return [2 /*return*/, _a.sent()];
-                            }
-                        }); }); },
-                    }];
-            }
+    UtilsTerminal.selectActionAndExecute = async (choices, options) => {
+        //#region @backendFunc
+        options = options || {};
+        options.question = options.question || 'Select action to execute';
+        options.executeActionOnDefault = core_imports_1._.isBoolean(options.executeActionOnDefault)
+            ? options.executeActionOnDefault
+            : true;
+        if (Object.keys(choices || {}).length === 0) {
+            await UtilsTerminal.pressAnyKeyToContinueAsync({
+                message: 'No choices available. Press any key to continue...',
+            });
+            return { selected: void 0, action: async () => void 0 };
+        }
+        const res = await UtilsTerminal.select({
+            ...options,
+            choices,
         });
-    }); };
+        // clearConsole();
+        let actionResult;
+        if (res &&
+            choices[res] &&
+            core_imports_1._.isFunction(choices[res].action) &&
+            options.executeActionOnDefault) {
+            actionResult = await choices[res].action();
+        }
+        // console.log(`Response from select: "${res}"`);
+        // pipeEnterToStdin();
+        return {
+            selected: res,
+            actionResult,
+            action: async () => await choices[res].action(),
+        };
+        //#endregion
+    };
     //#endregion
     //#region select
-    UtilsTerminal.select = function (options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var choices, preselectedIndex, prompt, AutoComplete, res, Select, res_1;
-        var _a;
-        return tslib_1.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    //#region @backendFunc
-                    options = core_imports_1._.cloneDeep(options);
-                    options.hint = core_imports_1._.isNil(options.hint)
-                        ? '- Space to select. Return to submit'
-                        : options.hint;
-                    options.autocomplete = core_imports_1._.isNil(options.autocomplete)
-                        ? true
-                        : options.autocomplete;
-                    choices = transformChoices(options.choices);
-                    preselectedIndex = choices.findIndex(function (c) { return c.value === options.defaultSelected; }) || 0;
-                    if (preselectedIndex === -1) {
-                        preselectedIndex = 0;
-                    }
-                    if (!options.autocomplete) return [3 /*break*/, 2];
-                    AutoComplete = require('enquirer').AutoComplete;
-                    prompt = new AutoComplete({
-                        name: 'value',
-                        message: options.question,
-                        limit: 10,
-                        multiple: false,
-                        initial: preselectedIndex,
-                        choices: choices,
-                        hint: options.hint,
-                        footer: function () {
-                            return core_imports_1.chalk.green('(Scroll up and down to reveal more choices)');
-                        },
-                    });
-                    return [4 /*yield*/, prompt.run()];
-                case 1:
-                    res = _b.sent();
-                    // console.log({choices})
-                    // console.log(`Selected!!!: "${res}" `);
-                    return [2 /*return*/, res];
-                case 2:
-                    Select = require('enquirer').Select;
-                    prompt = new Select({
-                        // name: 'value',
-                        message: options.question,
-                        choices: choices,
-                    });
-                    return [4 /*yield*/, prompt.run()];
-                case 3:
-                    res_1 = _b.sent();
-                    return [2 /*return*/, (_a = choices.find(function (c) { return c.name === res_1; })) === null || _a === void 0 ? void 0 : _a.value];
-            }
-        });
-    }); };
+    UtilsTerminal.select = async (options) => {
+        //#region @backendFunc
+        options = core_imports_1._.cloneDeep(options);
+        options.hint = core_imports_1._.isNil(options.hint)
+            ? '- Space to select. Return to submit'
+            : options.hint;
+        options.autocomplete = core_imports_1._.isNil(options.autocomplete)
+            ? true
+            : options.autocomplete;
+        const choices = transformChoices(options.choices);
+        let preselectedIndex = choices.findIndex(c => c.value === options.defaultSelected) || 0;
+        if (preselectedIndex === -1) {
+            preselectedIndex = 0;
+        }
+        let prompt;
+        // console.log({ choicesBefore: choices });
+        if (options.autocomplete) {
+            const { AutoComplete } = require('enquirer');
+            prompt = new AutoComplete({
+                name: 'value',
+                message: options.question,
+                limit: 10,
+                multiple: false,
+                initial: preselectedIndex,
+                choices,
+                hint: options.hint,
+                footer() {
+                    return core_imports_1.chalk.green('(Scroll up and down to reveal more choices)');
+                },
+            });
+            const res = await prompt.run();
+            // console.log({choices})
+            // console.log(`Selected!!!: "${res}" `);
+            return res;
+        }
+        else {
+            const { Select } = require('enquirer');
+            prompt = new Select({
+                // name: 'value',
+                message: options.question,
+                choices,
+            });
+            const res = await prompt.run();
+            return choices.find(c => c.name === res)?.value;
+        }
+        //#region does not work
+        // const choice = await multiselect<T>({
+        //   ...{
+        //     question,
+        //     choices,
+        //     autocomplete,
+        //     defaultSelected: [defaultSelected],
+        //   },
+        //   onlyOneChoice: true,
+        // });
+        // return _.first(choice) as T;
+        //#endregion
+        //#endregion
+    };
     //#endregion
     //#region pipe enter to stdin
-    UtilsTerminal.pipeEnterToStdin = function () {
+    UtilsTerminal.pipeEnterToStdin = () => {
         //#region @backendFunc
         process.stdin.push('\n');
         //#endregion
     };
     //#endregion
     //#region input
-    UtilsTerminal.input = function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
-        var initial, inquirer, response, anwser, error_1;
-        var defaultValue = _b.defaultValue, question = _b.question, required = _b.required;
-        return tslib_1.__generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    initial = defaultValue || '';
-                    return [4 /*yield*/, Promise.resolve().then(function () { return require('inquirer'); })];
-                case 1:
-                    inquirer = _c.sent();
-                    _c.label = 2;
-                case 2:
-                    if (!true) return [3 /*break*/, 7];
-                    _c.label = 3;
-                case 3:
-                    _c.trys.push([3, 5, , 6]);
-                    return [4 /*yield*/, inquirer.prompt({
-                            type: 'input',
-                            name: 'name',
-                            message: question,
-                            default: initial,
-                            // required: _.isNil(required) ? true : required,
-                        })];
-                case 4:
-                    response = _c.sent();
-                    anwser = response.name;
-                    if (required && !anwser) {
-                        console.warn("Answer is required...");
-                        return [3 /*break*/, 2];
-                    }
-                    return [2 /*return*/, anwser];
-                case 5:
-                    error_1 = _c.sent();
-                    console.error(error_1);
-                    if (required) {
-                        console.warn("Something went wrong, please try again...");
-                        return [3 /*break*/, 2];
-                    }
-                    else {
-                        return [2 /*return*/, ''];
-                    }
-                    return [3 /*break*/, 6];
-                case 6: return [3 /*break*/, 2];
-                case 7: return [2 /*return*/];
+    UtilsTerminal.input = async ({ defaultValue, question, required, // TODO something is werid with required
+     }) => {
+        //#region @backendFunc
+        const initial = defaultValue || '';
+        const inquirer = await Promise.resolve().then(() => require('inquirer'));
+        while (true) {
+            try {
+                // Create an input prompt
+                const response = await inquirer.prompt({
+                    type: 'input',
+                    name: 'name',
+                    message: question,
+                    default: initial,
+                    // required: _.isNil(required) ? true : required,
+                });
+                const anwser = response.name;
+                if (required && !anwser) {
+                    console.warn(`Answer is required...`);
+                    continue;
+                }
+                return anwser;
             }
-        });
-    }); };
+            catch (error) {
+                console.error(error);
+                if (required) {
+                    console.warn(`Something went wrong, please try again...`);
+                    continue;
+                }
+                else {
+                    return '';
+                }
+            }
+        }
+        //#endregion
+    };
     //#endregion
     //#region confirm
-    UtilsTerminal.confirm = function (options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var defaultValue, message, 
+    UtilsTerminal.confirm = async (options) => {
+        //#region @backendFunc
+        options = options || {};
+        options.defaultValue = core_imports_1._.isBoolean(options.defaultValue)
+            ? options.defaultValue
+            : true;
+        options.message = options.message || 'Are you sure?';
+        options.engine = options.engine || 'inquirer-toggle';
+        const { defaultValue, message, 
         // mustAnswerQuestion,
-        callbackFalse, callbackTrue, response, inquirerToggle, answer, confirm_1, answer, prompts, Select, choices, prompt_1;
-        var _a;
-        return tslib_1.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    //#region @backendFunc
-                    options = options || {};
-                    options.defaultValue = core_imports_1._.isBoolean(options.defaultValue)
-                        ? options.defaultValue
-                        : true;
-                    options.message = options.message || 'Are you sure?';
-                    options.engine = options.engine || 'inquirer-toggle';
-                    defaultValue = options.defaultValue, message = options.message, callbackFalse = options.callbackFalse, callbackTrue = options.callbackTrue;
-                    response = {
-                        value: defaultValue,
-                    };
-                    if (!global.tnpNonInteractive) return [3 /*break*/, 1];
-                    index_1.Helpers.info("".concat(message, " - AUTORESPONSE: ").concat(defaultValue ? 'YES' : 'NO'));
-                    return [3 /*break*/, 11];
-                case 1:
-                    if (!(options.engine === 'inquirer-toggle')) return [3 /*break*/, 4];
-                    return [4 /*yield*/, Promise.resolve().then(function () { return require('inquirer-toggle'); })];
-                case 2:
-                    inquirerToggle = (_b.sent()).default;
-                    return [4 /*yield*/, inquirerToggle({
-                            message: message,
-                            default: defaultValue,
-                            theme: {
-                                style: {
-                                    highlight: core_imports_1.chalk.bold.cyan.underline,
-                                },
-                            },
-                        })];
-                case 3:
-                    answer = _b.sent();
-                    response = {
-                        value: answer,
-                    };
-                    return [3 /*break*/, 11];
-                case 4:
-                    if (!(options.engine === '@inquirer/prompts')) return [3 /*break*/, 7];
-                    return [4 /*yield*/, Promise.resolve().then(function () { return require('@inquirer/prompts'); })];
-                case 5:
-                    confirm_1 = (_b.sent()).confirm;
-                    return [4 /*yield*/, confirm_1({
-                            message: message,
-                            default: defaultValue,
-                        })];
-                case 6:
-                    answer = _b.sent();
-                    response = {
-                        value: answer,
-                    };
-                    return [3 /*break*/, 11];
-                case 7:
-                    if (!(options.engine === 'prompts')) return [3 /*break*/, 9];
-                    prompts = require('prompts');
-                    return [4 /*yield*/, prompts({
-                            type: 'toggle',
-                            name: 'value',
-                            message: message,
-                            initial: defaultValue,
-                            active: 'yes',
-                            inactive: 'no',
-                        })];
-                case 8:
-                    response = _b.sent();
-                    return [3 /*break*/, 11];
-                case 9:
-                    if (!(options.engine === 'enquirer')) return [3 /*break*/, 11];
-                    Select = require('enquirer').Select;
-                    choices = defaultValue ? ['yes', 'no'] : ['no', 'yes'];
-                    prompt_1 = new Select({
-                        name: 'question',
-                        message: message,
-                        choices: choices,
-                    });
-                    _a = {};
-                    return [4 /*yield*/, prompt_1.run()];
-                case 10:
-                    response = (_a.value = (_b.sent()) === 'yes',
-                        _a);
-                    _b.label = 11;
-                case 11:
-                    if (!response.value) return [3 /*break*/, 14];
-                    if (!callbackTrue) return [3 /*break*/, 13];
-                    return [4 /*yield*/, index_1.Helpers.runSyncOrAsync({ functionFn: callbackTrue })];
-                case 12:
-                    _b.sent();
-                    _b.label = 13;
-                case 13: return [3 /*break*/, 16];
-                case 14:
-                    if (!callbackFalse) return [3 /*break*/, 16];
-                    return [4 /*yield*/, index_1.Helpers.runSyncOrAsync({ functionFn: callbackFalse })];
-                case 15:
-                    _b.sent();
-                    _b.label = 16;
-                case 16: return [2 /*return*/, response.value];
+        callbackFalse, callbackTrue, } = options;
+        let response = {
+            value: defaultValue,
+        };
+        if (global.tnpNonInteractive) {
+            index_1.Helpers.info(`${message} - AUTORESPONSE: ${defaultValue ? 'YES' : 'NO'}`);
+        }
+        else {
+            if (options.engine === 'inquirer-toggle') {
+                const inquirerToggle = (await Promise.resolve().then(() => require('inquirer-toggle'))).default;
+                const answer = await inquirerToggle({
+                    message,
+                    default: defaultValue,
+                    theme: {
+                        style: {
+                            highlight: core_imports_1.chalk.bold.cyan.underline,
+                        },
+                    },
+                });
+                response = {
+                    value: answer,
+                };
             }
-        });
-    }); };
+            else if (options.engine === '@inquirer/prompts') {
+                // @ts-ignore
+                const { confirm } = await Promise.resolve().then(() => require('@inquirer/prompts'));
+                const answer = await confirm({
+                    message,
+                    default: defaultValue,
+                });
+                response = {
+                    value: answer,
+                };
+            }
+            else if (options.engine === 'prompts') {
+                const prompts = require('prompts');
+                response = await prompts({
+                    type: 'toggle',
+                    name: 'value',
+                    message,
+                    initial: defaultValue,
+                    active: 'yes',
+                    inactive: 'no',
+                });
+            }
+            else if (options.engine === 'enquirer') {
+                const { Select } = require('enquirer');
+                const choices = defaultValue ? ['yes', 'no'] : ['no', 'yes'];
+                const prompt = new Select({
+                    name: 'question',
+                    message,
+                    choices,
+                });
+                response = {
+                    value: (await prompt.run()) === 'yes',
+                };
+            }
+        }
+        if (response.value) {
+            if (callbackTrue) {
+                await index_1.Helpers.runSyncOrAsync({ functionFn: callbackTrue });
+            }
+        }
+        else {
+            if (callbackFalse) {
+                await index_1.Helpers.runSyncOrAsync({ functionFn: callbackFalse });
+            }
+        }
+        return response.value;
+        //#endregion
+    };
     //#endregion
     //#region press any key to continue
-    UtilsTerminal.pressAnyKeyToContinueAsync = function (options) {
+    UtilsTerminal.pressAnyKeyToContinueAsync = (options) => {
         //#region @backendFunc
         options = options || {};
         options.message =
             options.message || core_imports_1.chalk.bold('Press any key to continue...');
-        var message = options.message;
-        var readline = require('readline');
-        return new Promise(function (resolve) {
-            var rl = readline.createInterface({
+        const { message } = options;
+        const readline = require('readline');
+        return new Promise(resolve => {
+            const rl = readline.createInterface({
                 input: process.stdin,
                 output: process.stdout,
             });
             // Prompt user with the question
-            rl.question(message, function (answer) {
+            rl.question(message, answer => {
                 rl.close();
                 resolve(answer);
             });
@@ -1782,18 +1904,18 @@ var UtilsTerminal;
     /**
      * @deprecated use UtilsTerminal.pressAnyKeyToContinueAsync()
      */
-    UtilsTerminal.pressAnyKey = function (options) {
+    UtilsTerminal.pressAnyKey = (options) => {
         //#region @backendFunc
         options = options || {};
         options.message = options.message || 'Press any key to continue...';
-        var message = options.message;
+        const { message } = options;
         if (process.platform === 'win32') {
-            var terminal = UtilsProcess.getBashOrShellName();
+            const terminal = UtilsProcess.getBashOrShellName();
             // console.log({ terminal });
             if (terminal === 'gitbash') {
-                var getGitBashPath = UtilsProcess.getGitBashPath();
+                const getGitBashPath = UtilsProcess.getGitBashPath();
                 // console.log({ getGitBashPath });
-                var gitbashCommand = "read -p \"".concat(core_imports_1.chalk.bold(message), "\"");
+                const gitbashCommand = `read -p "${core_imports_1.chalk.bold(message)}"`;
                 core_imports_3.child_process.execSync(gitbashCommand, {
                     stdio: 'inherit',
                     shell: getGitBashPath,
@@ -1814,41 +1936,25 @@ var UtilsTerminal;
     };
     //#endregion
     //#region preview long list as select
-    UtilsTerminal.previewLongList = function (list_1) {
-        var args_1 = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args_1[_i - 1] = arguments[_i];
-        }
-        return tslib_1.__awaiter(_this, tslib_1.__spreadArray([list_1], tslib_1.__read(args_1), false), void 0, function (list, listName) {
-            var choices;
-            if (listName === void 0) { listName = 'List'; }
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        //#region @backendFunc
-                        if (!Array.isArray(list)) {
-                            list = list.split('\n');
-                        }
-                        choices = list.reduce(function (a, b) {
-                            var _a;
-                            return core_imports_1._.merge(a, (_a = {},
-                                _a[b] = {
-                                    name: b,
-                                    // action: () => {},
-                                },
-                                _a));
-                        }, {});
-                        return [4 /*yield*/, UtilsTerminal.selectActionAndExecute(choices, {
-                                autocomplete: true,
-                                question: listName,
-                                hint: 'Press enter to return',
-                            })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
+    UtilsTerminal.previewLongList = async (list, listName = 'List') => {
+        //#region @backendFunc
+        if (!Array.isArray(list)) {
+            list = list.split('\n');
+        }
+        const choices = list.reduce((a, b) => {
+            return core_imports_1._.merge(a, {
+                [b]: {
+                    name: b,
+                    // action: () => {},
+                },
             });
+        }, {});
+        await UtilsTerminal.selectActionAndExecute(choices, {
+            autocomplete: true,
+            question: listName,
+            hint: 'Press enter to return',
         });
+        //#endregion
     };
     //#endregion
     //#region preview long list with 'less' (git log like)
@@ -1859,26 +1965,26 @@ var UtilsTerminal;
      * @param {string} list - The long string content to display.
      * @returns {Promise<void>} A Promise that resolves when the pager exits.
      */
-    UtilsTerminal.previewLongListGitLogLike = function (list) {
+    UtilsTerminal.previewLongListGitLogLike = (list) => {
         //#region @backendFunc
         if (Array.isArray(list)) {
             list = list.join('\n');
         }
-        return new Promise(function (resolve, reject) {
-            var less = (0, core_imports_3.spawn)('less', [], {
+        return new Promise((resolve, reject) => {
+            const less = (0, core_imports_3.spawn)('less', [], {
                 stdio: ['pipe', process.stdout, process.stderr],
             });
             less.stdin.write(list); // Write the list content to the less process
             less.stdin.end(); // Signal that writing is complete
-            less.on('close', function (code) {
+            less.on('close', code => {
                 if (code === 0) {
                     resolve(void 0);
                 }
                 else {
-                    reject(new Error("less process exited with code ".concat(code)));
+                    reject(new Error(`less process exited with code ${code}`));
                 }
             });
-            less.on('error', function (err) {
+            less.on('error', err => {
                 reject(err);
             });
         });