tnp-core 18.0.37 → 18.0.40

package/lib/utils.d.ts

@@ -10,6 +10,10 @@ export declare namespace Utils {
     export function removeChalkSpecialChars(str: string): string;
     export const fullDateTime: () => string;
     export const fullDate: () => string;
+    export const getFreePort: (options?: {
+        startFrom?: number;
+        howManyFreePortsAfterThatPort?: number;
+    }) => Promise<number>;
     interface AttrJsoncProp {
         name: string;
         value?: any;
@@ -91,56 +95,103 @@ export declare namespace Utils {
          */
         function numValue(pixelsCss: string | number): number;
     }
-    export namespace process {
-        interface ProcessStartOptions {
-            /**
-             * by default is process.cwd();
-             */
-            cwd?: string;
-            showCommand?: boolean;
-            /**
-             * Modify output line by line
-             */
-            outputLineReplace?: (outputLineStderOrStdout: string) => string;
-            resolvePromiseMsg?: {
-                /**
-                 * unitil this string is in output of stdout
-                 */
-                stdout?: string | string[];
-                /**
-                 * unitil this string is in output of stderr
-                 */
-                stderr?: string | string[];
-                /**
-                 * by default only resolve when exit code is 0
-                 */
-                resolveAfterAnyExitCode?: boolean;
-            };
+    export {};
+}
+export declare namespace UtilsProcess {
+    interface ProcessStartOptions {
+        /**
+         * by default is process.cwd();
+         */
+        cwd?: string;
+        /**
+         * by default is false
+         */
+        showCommand?: boolean;
+        /**
+         * Modify output line by line
+         */
+        outputLineReplace?: (outputLineStderOrStdout: string) => string;
+        resolvePromiseMsg?: {
             /**
-             * Prefix messages output from child_prcess
+             * until this string is in output of stdout
              */
-            prefix?: string;
+            stdout?: string | string[];
             /**
-             * Try command again after fail after n miliseconds
+             * until this string is in output of stderr
              */
-            tryAgainWhenFailAfter?: number;
-            askToTryAgainOnError?: boolean;
-            exitOnErrorCallback?: (code: number) => void;
+            stderr?: string | string[];
             /**
-             * Use big buffer for big webpack logs
+             * by default only resolve when exit code is 0
              */
-            biggerBuffer?: boolean;
-            hideOutput?: {
-                stdout?: boolean;
-                stderr?: boolean;
-            };
-        }
-        function startAsync(command: string, options?: ProcessStartOptions & {
-            detach?: boolean;
-        }): Promise<void>;
-        function startSync(command: string, options?: ProcessStartOptions): void;
+            resolveAfterAnyExitCode?: boolean;
+        };
+        /**
+         * Prefix messages output from child_process
+         */
+        prefix?: string;
+        /**
+         * Try command again after fail after n milliseconds
+         */
+        tryAgainWhenFailAfter?: number;
+        askToTryAgainOnError?: boolean;
+        exitOnErrorCallback?: (code: number) => void;
+        /**
+         * Use big buffer for big webpack logs
+         * (it may slow down smaller processes execution)
+         */
+        biggerBuffer?: boolean;
+        hideOutput?: {
+            stdout?: boolean;
+            stderr?: boolean;
+        };
     }
-    export {};
+    /**
+     * TODO IMPLEMENT
+     * start async node process
+     */
+    function startAsync(command: string, options?: ProcessStartOptions): Promise<void>;
+    /**
+     * TODO IMPLEMENT
+     */
+    function startSync(command: string, options?: ProcessStartOptions): void;
+    const getGitBashPath: () => string;
+    /**
+     * TODO IMPLEMENT
+     * start async node process
+     */
+    const startInNewTerminalWindow: (command: string, options?: Pick<ProcessStartOptions, "cwd" | "hideOutput">) => any;
+    const getBashOrShellName: () => "browser" | "cmd" | "powershell" | "gitbash" | "cygwin" | "unknown" | "bash" | "zsh" | "fish" | "sh";
+}
+export declare namespace UtilsOs {
+    /**
+     * check if script is running in client browser
+     * (websql model -> is also considered as browser
+     * because it is running in browser)
+     */
+    const isRunningInBrowser: () => boolean;
+    /**
+     * check if script is running in nodejs
+     * (backend script or electron script)
+     */
+    const isRunningInNode: () => boolean;
+    /**
+     * check if script is running special
+     * browser mode that has sql.js backend
+     * and executes sql queries in browser
+     */
+    const isRunningInWebSQL: () => boolean;
+    /**
+     * check whether the current process is running inside
+     * Electron backend or browser.
+     */
+    const isRunningInElectron: () => boolean;
+    /**
+     * Check wether the current process is running inside
+     * windows subsystem for linux (WSL).
+     */
+    const isRunningInWsl: () => boolean;
+    const isRunningInDocker: () => boolean;
+    const isRunningInLinuxGraphicsCapableEnvironment: () => boolean;
 }
 export declare namespace UtilsString {
     const kebabCaseNoSplitNumbers: (input: string) => string;

package/lib/utils.js

@@ -1,17 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UtilsString = exports.Utils = void 0;
+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");
 //#region @backend
 var core_imports_2 = require("./core-imports");
+var core_imports_3 = require("./core-imports");
 var buffer_1 = require("buffer");
 //#endregion
 var BLOB_SUPPORTED_IN_SQLJS = false;
+//#region utils
 var Utils;
 (function (Utils) {
+    var _this = this;
+    //#region utils / uniq array
     Utils.uniqArray = function (array, uniqueProperty) {
         var seen = {};
         return array
@@ -22,6 +27,8 @@ var Utils;
                 : (seen[uniqueProperty ? item[uniqueProperty] : item] = true);
         });
     };
+    //#endregion
+    //#region utils / escape string for reg exp
     /**
      * Example:
      * new RegExp(escapeStringForRegEx('a.b.c'),'g') => /a\.b\.c/g
@@ -29,6 +36,8 @@ var Utils;
     Utils.escapeStringForRegEx = function (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;
@@ -36,16 +45,66 @@ var Utils;
         return str.replace(ansiRegex, '');
     }
     Utils.removeChalkSpecialChars = removeChalkSpecialChars;
+    //#endregion
+    //#region utils / full date time
     Utils.fullDateTime = function () {
         //#region @backendFunc
-        return (0, core_imports_2.dateformat)(new Date(), 'dd-mm-yyyy HH:MM:ss');
+        return (0, core_imports_3.dateformat)(new Date(), 'dd-mm-yyyy HH:MM:ss');
         //#endregion
     };
+    //#endregion
+    //#region utils / full date
     Utils.fullDate = function () {
         //#region @backendFunc
-        return (0, core_imports_2.dateformat)(new Date(), 'dd-mm-yyyy');
+        return (0, core_imports_3.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, howManyFreePortsAfterThatPort, 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;
+                    howManyFreePortsAfterThatPort = options.howManyFreePortsAfterThatPort || 1;
+                    max = 5000;
+                    i = 0;
+                    if (core_imports_1._.isNumber(startFrom)) {
+                        while (takenPorts.includes(startFrom)) {
+                            startFrom += 1 + howManyFreePortsAfterThatPort;
+                        }
+                    }
+                    _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*/, core_imports_1.portfinder.getPortPromise({ port: startFrom })];
+                case 3:
+                    port = _a.sent();
+                    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:
+                    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*/];
+            }
+        });
+    }); };
     var json;
     (function (json) {
         json.getAtrributies = function (jsonDeepPath, // lodash path to property in json ex. deep.path.to.prop
@@ -724,22 +783,330 @@ var Utils;
         //#endregion
     })(css = Utils.css || (Utils.css = {}));
     //#endregion
-    //#region process
-    var process;
-    (function (process) {
-        function startAsync(command, options) {
-            return tslib_1.__awaiter(this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+})(Utils || (exports.Utils = Utils = {}));
+//#endregion
+//#region utils process
+var UtilsProcess;
+(function (UtilsProcess) {
+    //#endregion
+    //#region utils process  / TODO start async
+    /**
+     * TODO IMPLEMENT
+     * start async node process
+     */
+    function startAsync(command, options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
                 return [2 /*return*/];
-            }); });
+            });
+        });
+    }
+    UtilsProcess.startAsync = startAsync;
+    //#endregion
+    //#region utils process  / TODO start sync
+    /**
+     * TODO IMPLEMENT
+     */
+    function startSync(command, options) {
+        // TODO @LAST
+    }
+    UtilsProcess.startSync = startSync;
+    //#endregion
+    //#region utils process  / get git bash path
+    UtilsProcess.getGitBashPath = function () {
+        //#region @backendFunc
+        if (process.platform !== 'win32') {
+            return null;
+        }
+        try {
+            // Execute the 'where' command to find bash.exe
+            var gitBashPath = core_imports_2.child_process
+                .execSync('where bash.exe', { encoding: 'utf8' })
+                .split('\n')[0]
+                .trim();
+            if (gitBashPath) {
+                return (0, core_imports_1.crossPlatformPath)(gitBashPath);
+            }
+            return null; // Return the first match
+        }
+        catch (err) {
+            return null;
+        }
+        //#endregion
+    };
+    //#endregion
+    //#region utils process  / start process in new graphical terminal window
+    /**
+     * TODO IMPLEMENT
+     * start async node process
+     */
+    UtilsProcess.startInNewTerminalWindow = function (command, options) {
+        var e_3, _a;
+        //#region @backendFunc
+        var platform = process.platform;
+        options = options || {};
+        options.cwd = options.cwd || process.cwd();
+        if (platform === 'win32') {
+            var gitBashPath = UtilsProcess.getGitBashPath();
+            // const currentBash = getBashOrShellName();
+            // console.log('gitBashPath', gitBashPath);
+            // console.log('currentBash', currentBash);
+            if (gitBashPath) {
+                return (0, core_imports_2.spawn)('start bash', ['-c', "".concat(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,
+                }).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        ");
+            // For Windows
+            return (0, core_imports_2.spawn)('cmd', ['/c', 'start', 'cmd', '/k', "".concat(command)], {
+                detached: true,
+                stdio: 'ignore',
+                cwd: options === null || options === void 0 ? void 0 : options.cwd,
+            }).unref();
         }
-        process.startAsync = startAsync;
-        function startSync(command, options) { }
-        process.startSync = startSync;
-    })(process = Utils.process || (Utils.process = {}));
+        else if (platform === 'darwin') {
+            // For macOS
+            return (0, core_imports_2.spawn)('osascript', ['-e', "tell application \"Terminal\" to do script \"".concat(command, "\"")], {
+                detached: true,
+                stdio: 'ignore',
+                cwd: options === null || options === void 0 ? void 0 : options.cwd,
+            }).unref();
+        }
+        else if (platform === 'linux') {
+            if (!UtilsOs.isRunningInLinuxGraphicsCapableEnvironment()) {
+                var child_1 = core_imports_2.child_process.spawn(command, {
+                    detached: true,
+                    cwd: options === null || options === void 0 ? void 0 : options.cwd,
+                    stdio: 'ignore',
+                });
+                child_1.unref();
+                return;
+            }
+            // For Linux (gnome-terminal as an example)
+            var terminals = [
+                { cmd: 'gnome-terminal', args: ['--'] },
+                { cmd: 'konsole', args: ['-e'] },
+                { cmd: 'xfce4-terminal', args: ['-e'] },
+                { cmd: 'xterm', args: ['-e'] },
+                { cmd: 'lxterminal', args: ['-e'] },
+                { cmd: 'mate-terminal', args: ['-e'] },
+                { cmd: 'terminator', args: ['-e'] },
+                { cmd: 'tilix', args: ['-e'] },
+                { cmd: 'alacritty', args: ['-e'] },
+                { cmd: 'urxvt', args: ['-e'] },
+            ];
+            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_2.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 {
+                try {
+                    if (terminals_1_1 && !terminals_1_1.done && (_a = terminals_1.return)) _a.call(terminals_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            if (!terminalCommand) {
+                console.error('No supported terminal emulator found.');
+                return;
+            }
+            var child = (0, core_imports_2.spawn)(terminalCommand, terminalArgs, {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+        }
+        else {
+            index_1.Helpers.throw("Unsupported platform: ".concat(platform));
+        }
+        //#endregion
+    };
     //#endregion
-})(Utils || (exports.Utils = Utils = {}));
+    //#region utils process / get bash or shell name
+    UtilsProcess.getBashOrShellName = function () {
+        /* */
+        /* */
+        //#region @backendFunc
+        var platform = process.platform; // Identify the platform: 'win32', 'darwin', 'linux'
+        var shell = process.env.SHELL || process.env.ComSpec || ''; // Common shell environment variables
+        if (platform === 'win32') {
+            if (shell.includes('cmd.exe'))
+                return 'cmd';
+            if (shell.includes('powershell.exe') || shell.includes('pwsh'))
+                return 'powershell';
+            // Heuristic for Git Bash
+            if (process.env.MSYSTEM &&
+                process.env.MSYSTEM.toLowerCase().includes('mingw')) {
+                return 'gitbash';
+            }
+            // Heuristic for Cygwin
+            if (shell.includes('cygwin')) {
+                return 'cygwin';
+            }
+            return 'unknown'; // Default for unrecognized shells on Windows
+        }
+        else {
+            // For macOS and Linux
+            if (shell.includes('bash'))
+                return 'bash';
+            if (shell.includes('zsh'))
+                return 'zsh';
+            if (shell.includes('fish'))
+                return 'fish';
+            if (shell.includes('sh'))
+                return 'sh';
+            return 'unknown'; // Default for unrecognized shells on Unix-based systems
+        }
+        //#endregion
+    };
+    //#endregion
+})(UtilsProcess || (exports.UtilsProcess = UtilsProcess = {}));
+//#endregion
+//#region utils os
+var UtilsOs;
+(function (UtilsOs) {
+    //#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 () {
+        //#region @backend
+        return false;
+        //#endregion
+        return true;
+    };
+    //#endregion
+    //#region utils os / is running in node
+    /**
+     * check if script is running in nodejs
+     * (backend script or electron script)
+     */
+    UtilsOs.isRunningInNode = function () {
+        //#region @backend
+        return true;
+        //#endregion
+        return false;
+    };
+    //#endregion
+    //#region utils os / is running in websql
+    /**
+     * check if script is running special
+     * browser mode that has sql.js backend
+     * and executes sql queries in browser
+     */
+    UtilsOs.isRunningInWebSQL = function () {
+        //#region @backend
+        return false;
+        //#endregion
+        /* */
+        /* */
+        return false;
+    };
+    //#endregion
+    //#region utils os / is running in electron
+    /**
+     * check whether the current process is running inside
+     * Electron backend or browser.
+     */
+    UtilsOs.isRunningInElectron = function () {
+        // Renderer process
+        // @ts-ignore
+        if (typeof window !== 'undefined' &&
+            typeof window.process === 'object' &&
+            window.process.type === 'renderer') {
+            return true;
+        }
+        // Main process
+        // @ts-ignore
+        if (typeof process !== 'undefined' &&
+            typeof process.versions === 'object' &&
+            !!process.versions.electron) {
+            return true;
+        }
+        // Detect the user agent when the `nodeIntegration` option is set to false
+        if (typeof navigator === 'object' &&
+            typeof navigator.userAgent === 'string' &&
+            navigator.userAgent.indexOf('Electron') >= 0) {
+            return true;
+        }
+        return false;
+    };
+    //#endregion
+    //#region utils os / is running in wsl
+    /**
+     * Check wether the current process is running inside
+     * windows subsystem for linux (WSL).
+     */
+    UtilsOs.isRunningInWsl = function () {
+        //#region @backendFunc
+        if (process.platform !== 'linux') {
+            return false;
+        }
+        if (core_imports_1.os.release().toLowerCase().includes('microsoft')) {
+            return true;
+        }
+        try {
+            return core_imports_3.fse
+                .readFileSync('/proc/version', 'utf8')
+                .toLowerCase()
+                .includes('microsoft');
+        }
+        catch (_) {
+            return false;
+        }
+        //#endregion
+    };
+    //#endregion
+    //#region utils os / is running in docker
+    UtilsOs.isRunningInDocker = function () {
+        //#region @backendFunc
+        try {
+            var cgroup = core_imports_3.fse.readFileSync('/proc/1/cgroup', 'utf8');
+            return /docker|kubepods|containerd/.test(cgroup);
+        }
+        catch (e) {
+            return false; // If the file does not exist or cannot be read, assume not running in Docker
+        }
+        //#endregion
+    };
+    //#endregion
+    //#region utils os / is running in linux graphics capable environment
+    UtilsOs.isRunningInLinuxGraphicsCapableEnvironment = function () {
+        //#region @backendFunc
+        if (core_imports_1.os.platform() !== 'linux') {
+            return false;
+        }
+        // Check for the DISPLAY environment variable
+        return !!process.env.DISPLAY;
+        //#endregion
+    };
+    //#endregion
+})(UtilsOs || (exports.UtilsOs = UtilsOs = {}));
+//#endregion
+//#region utils string
 var UtilsString;
 (function (UtilsString) {
+    //#region utils string / kebab case no split numbers
     UtilsString.kebabCaseNoSplitNumbers = function (input) {
         return (input
             // Match spaces or any kind of whitespace and replace with a hyphen
@@ -749,5 +1116,7 @@ var UtilsString;
             // Convert everything to lowercase
             .toLowerCase());
     };
+    //#endregion
 })(UtilsString || (exports.UtilsString = UtilsString = {}));
+//#endregion
 //# sourceMappingURL=utils.js.map