tnp-core 18.0.42 → 18.0.44

package/lib/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UtilsMigrations = exports.UtilsString = exports.UtilsOs = exports.UtilsProcess = exports.Utils = void 0;
+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");
@@ -11,6 +11,7 @@ var core_imports_2 = require("./core-imports");
 var core_imports_3 = require("./core-imports");
 var core_imports_4 = require("./core-imports");
 var buffer_1 = require("buffer");
+var net = require("net");
 //#endregion
 var BLOB_SUPPORTED_IN_SQLJS = false;
 //#region utils
@@ -984,6 +985,7 @@ var UtilsProcess;
 //#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
@@ -1106,6 +1108,111 @@ var UtilsOs;
         //#endregion
     };
     //#endregion
+    //#region utils os / is running in cli mode
+    /**
+     * Check whether the current process is running in CLI mode.
+     */
+    UtilsOs.isRunningInCliMode = function () {
+        /* */
+        /* */
+        //#region @backendFunc
+        return !!global['globalSystemToolMode'];
+        //#endregion
+    };
+    //#endregion
+    //#region utils os / is running in mocha test
+    /**
+     * Check whether the current process is running in mocha test.
+     */
+    UtilsOs.isRunningInMochaTest = function () {
+        /* */
+        /* */
+        //#region @backendFunc
+        return typeof global['it'] === 'function';
+        //#endregion
+    };
+    //#endregion
+    //#region utils os / is port in use
+    var isPortInUseOnHost = function (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
+                    });
+                });
+                server.listen(port, host);
+                return [2 /*return*/];
+            });
+        }); });
+        //#endregion
+    };
+    /**
+     * Checks if a given port is already in use (bound by another process).
+     *
+     * @param port - The port number to check.
+     * @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]
+                        : ['::', '0.0.0.0', '127.0.0.1'];
+                    _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];
+            }
+        });
+    }); };
+    //#endregion
 })(UtilsOs || (exports.UtilsOs = UtilsOs = {}));
 //#endregion
 //#region utils string
@@ -1159,4 +1266,476 @@ var UtilsMigrations;
     };
 })(UtilsMigrations || (exports.UtilsMigrations = UtilsMigrations = {}));
 //#endregion
+//#region utils terminal
+var UtilsTerminal;
+(function (UtilsTerminal) {
+    var _this = this;
+    //#region clear
+    UtilsTerminal.clearConsole = function () {
+        //#region @backendFunc
+        index_1.Helpers.msgCacheClear();
+        console.log('\x1Bc');
+        // process.stdout.write('\033c\033[3J');
+        // try {
+        //   run('clear').sync()
+        // } catch (error) {
+        //   console.log('clear console not succedd')
+        // }
+        //#endregion
+    };
+    //#endregion
+    //#region transform choices
+    var transformChoices = function (choices) {
+        //#region @backendFunc
+        if (!core_imports_1._.isArray(choices) && core_imports_1._.isObject(choices)) {
+            choices = Object.keys(choices)
+                .map(function (key) {
+                return {
+                    name: choices[key].name,
+                    value: key,
+                };
+            })
+                .reduce(function (a, b) { return a.concat(b); }, []);
+        }
+        return choices.map(function (c) { return ({ 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);
+                    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 3:
+                    res = _a.sent();
+                    return [2 /*return*/, (Array.isArray(res) ? res : [res])];
+            }
+        });
+    }); };
+    /**
+     * 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;
+        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;
+                    return [4 /*yield*/, UtilsTerminal.select(tslib_1.__assign(tslib_1.__assign({}, options), { choices: choices }))];
+                case 1:
+                    res = _a.sent();
+                    if (!(res &&
+                        choices[res] &&
+                        core_imports_1._.isFunction(choices[res].action) &&
+                        options.executeActionOnDefault)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, choices[res].action()];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3: 
+                // console.log(`Response from select: "${res}"`);
+                // pipeEnterToStdin();
+                return [2 /*return*/, { selected: res, 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()];
+                            }
+                        }); }); } }];
+            }
+        });
+    }); };
+    //#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];
+            }
+        });
+    }); };
+    //#endregion
+    //#region pipe enter to stdin
+    UtilsTerminal.pipeEnterToStdin = function () {
+        //#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*/];
+            }
+        });
+    }); };
+    //#endregion
+    //#region confirm
+    UtilsTerminal.confirm = function (options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        var 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];
+            }
+        });
+    }); };
+    //#endregion
+    //#region press any key to continue
+    UtilsTerminal.pressAnyKeyToContinueAsync = function (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({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            // Prompt user with the question
+            rl.question(message, function (answer) {
+                rl.close();
+                resolve(answer);
+            });
+        });
+        //#endregion
+    };
+    //#endregion
+    //#region press any key
+    /**
+     * @deprecated use UtilsTerminal.pressAnyKeyToContinueAsync()
+     */
+    UtilsTerminal.pressAnyKey = function (options) {
+        //#region @backendFunc
+        options = options || {};
+        options.message = options.message || 'Press any key to continue...';
+        var message = options.message;
+        if (process.platform === 'win32') {
+            var terminal = UtilsProcess.getBashOrShellName();
+            // console.log({ terminal });
+            if (terminal === 'gitbash') {
+                var getGitBashPath = UtilsProcess.getGitBashPath();
+                // console.log({ getGitBashPath });
+                var gitbashCommand = "read -p \"".concat(core_imports_1.chalk.bold(message), "\"");
+                core_imports_3.child_process.execSync(gitbashCommand, {
+                    stdio: 'inherit',
+                    shell: getGitBashPath,
+                });
+            }
+            else {
+                console.log(core_imports_1.chalk.bold(message));
+                core_imports_3.spawn.sync('pause', '', { shell: true, stdio: [0, 1, 2] });
+            }
+            return;
+        }
+        console.log(core_imports_1.chalk.bold(message));
+        require('child_process').spawnSync('read _ ', {
+            shell: true,
+            stdio: [0, 1, 2],
+        });
+        //#endregion
+    };
+    //#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*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region preview long list with 'less' (git log like)
+    /**
+     * Displays a long list in the console using a pager like `less`.
+     * Returns a Promise that resolves when the user exits the pager.
+     *
+     * @param {string} list - The long string content to display.
+     * @returns {Promise<void>} A Promise that resolves when the pager exits.
+     */
+    UtilsTerminal.previewLongListGitLogLike = function (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', [], {
+                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) {
+                if (code === 0) {
+                    resolve(void 0);
+                }
+                else {
+                    reject(new Error("less process exited with code ".concat(code)));
+                }
+            });
+            less.on('error', function (err) {
+                reject(err);
+            });
+        });
+        //#endregion
+    };
+    //#endregion
+})(UtilsTerminal || (exports.UtilsTerminal = UtilsTerminal = {}));
+//#endregion
 //# sourceMappingURL=utils.js.map