last changes before repacking Pack 1 ...

Documents/JsModules/x-color.tools.js

@@ -0,0 +1,506 @@
+/**
+ * XColor Tools Module ...
+ * a module for handle colorify text contents in node js ...
+ * 
+ * Maintainer
+ * 
+ * Hadi Khazaee Asl <https://saherelm.ir> (hadi_khazaee_asl@yahoo.com)
+ */
+
+//
+//#region Module Imports ...
+const XValueTools = require("./x-value.tools");
+//#endregion
+
+//
+//#region Constants ...
+/**
+ * these are available style which can applied to an string ...
+ */
+const AVAILABLE_STYLES = {
+    //
+    Bold: "\x1b[1m",
+    Dim: "\x1b[2m",
+    Underlined: "\x1b[4m",
+    Blink: "\x1b[5m",
+    ReverseFandB: "\x1b[7m",
+    Hidden: "\x1b[8m",
+    //
+    // Commonly used for reset all Styles ...
+    Reset: "\x1b[0m"
+};
+
+/**
+ * these are available foreground colors which can applied to an string ...
+ */
+const AVAILABLE_FOREGROUND_COLORS = {
+    Default: "\x1b[39m",
+    Black: "\x1b[30m",
+    Red: "\x1b[31m",
+    Green: "\x1b[32m",
+    Yellow: "\x1b[33m",
+    Blue: "\x1b[34m",
+    Magenta: "\x1b[35m",
+    Cyan: "\x1b[36m",
+    LightGray: "\x1b[37m",
+    DarkGray: "\x1b[90m",
+    LightRed: "\x1b[91m",
+    LightGreen: "\x1b[92m",
+    LightYellow: "\x1b[93m",
+    LightBlue: "\x1b[94m",
+    LightMagenta: "\x1b[95m",
+    LightCyan: "\x1b[96m",
+    White: "\x1b[97m",
+};
+
+/**
+ * these are available background colors which can applied to an string ...
+ */
+const AVAILABLE_BACKGROUND_COLORS = {
+    Default: "\x1b[49m",
+    Black: "\x1b[40m",
+    Red: "\x1b[41m",
+    Green: "\x1b[42m",
+    Yellow: "\x1b[43m",
+    Blue: "\x1b[44m",
+    Magenta: "\x1b[45m",
+    Cyan: "\x1b[46m",
+    LightGray: "\x1b[47m",
+    DarkGray: "\x1b[100m",
+    LightRed: "\x1b[101m",
+    LightGreen: "\x1b[102m",
+    LightYellow: "\x1b[103m",
+    LightBlue: "\x1b[104m",
+    LightMagenta: "\x1b[105m",
+    LightCyan: "\x1b[106m",
+    White: "\x1b[107m",
+};
+
+/**
+ * these are available style names, which exports from module and
+ * users can use them ...
+ */
+const STYLE_NAMES = {
+    Bold: "Bold",
+    Dim: "Dim",
+    Underlined: "Underlined",
+    Blink: "Blink",
+    ReverseFandB: "ReverseFandB",
+    Hidden: "Hidden",
+    Reset: "Reset",
+};
+
+/**
+ * these are available color names, which exports from module and
+ * users can use them ...
+ */
+const COLOR_NAMES = {
+    Default: "Default",
+    Black: "Black",
+    Red: "Red",
+    Green: "Green",
+    Yellow: "Yellow",
+    Blue: "Blue",
+    Magenta: "Magenta",
+    Cyan: "Cyan",
+    LightGray: "LightGray",
+    DarkGray: "DarkGray",
+    LightRed: "LightRed",
+    LightGreen: "LightGreen",
+    LightYellow: "LightYellow",
+    LightBlue: "LightBlue",
+    LightMagenta: "LightMagenta",
+    LightCyan: "LightCyan",
+    White: "White",
+};
+//#endregion
+
+//
+//#region Actions ...
+/**
+ * apply specified style and color on a content ...
+ * 
+ * @param {string} content specified content for styling ...
+ * @param {string} color specific color name for using to styling ...
+ * @param {string} style soecufic style name to use ...
+ * @param {boolean} toForeground apply specified color as foreground ...
+ * @param {boolean} toBackground apply specified color as background ...
+ * @returns {string} styled content ...
+ */
+function apply(
+    content,
+    color,
+    style,
+    toForeground = true,
+    toBackground = false
+) {
+    //
+    let result = content;
+
+    //
+    // Validate Arg ...
+    if (!XValueTools.isValidArg(content)) {
+        return result;
+    }
+
+    //
+    // Detect and Validate Style and Apply it ...
+    let eStyle = AVAILABLE_STYLES[style];
+    if (XValueTools.isValidArg(eStyle)) {
+        result = `${eStyle}${result}${AVAILABLE_STYLES.Reset}`;
+    }
+
+    //
+    // Detect and Validate Foreground Color and Apply it ...
+    let eFColor = AVAILABLE_FOREGROUND_COLORS[color];
+    if (
+        !!toForeground
+        && XValueTools.isValidArg(eFColor)
+    ) {
+        result = `${eFColor}${result}${AVAILABLE_STYLES.Reset}`;
+    }
+
+    //
+    // Detect and Validate Background Color and Apply it ...
+    let eBColor = AVAILABLE_BACKGROUND_COLORS[color];
+    if (
+        !!toBackground
+        && XValueTools.isValidArg(eBColor)
+    ) {
+        result = `${eBColor}${result}${AVAILABLE_STYLES.Reset}`;
+    }
+
+}
+
+/**
+ * apply specific style on a content ...
+ * 
+ * @param {string} content specific content which going to styled ...
+ * @param {string} style a member of STYLE_NAMES which specified that which style going to applied to content ...
+ * @returns {string} styled content ...
+ */
+function applyStyle(content, style) {
+    //
+    // Validate Arg ...
+    if (!XValueTools.isValidArg(content)) {
+        return content;
+    }
+
+    //
+    let eStyle = AVAILABLE_STYLES[style];
+    if (eStyle === undefined) {
+        return content;
+    }
+
+    //
+    return `${eStyle}${content}${AVAILABLE_STYLES.Reset}`;
+}
+
+/**
+ * apply specific foreground color on a content ...
+ * 
+ * @param {string} content specific content which going to colorified ...
+ * @param {string} color a member of COLOR_NAMES which specified that which color going to applied to content ...
+ * @returns {string} colorified content ...
+ */
+function applyForegroundColor(content, color) {
+    //
+    // Validate Arg ...
+    if (!XValueTools.isValidArg(content)) {
+        return content;
+    }
+
+    //
+    let eColor = AVAILABLE_FOREGROUND_COLORS[color];
+    if (eColor === undefined) {
+        return content;
+    }
+
+    //
+    return `${eColor}${content}${AVAILABLE_STYLES.Reset}`;
+}
+
+/**
+ * apply specific background color on a content ...
+ * 
+ * @param {string} content specific content which going to colorified ...
+ * @param {string} color a member of COLOR_NAMES which specified that which color going to applied to content ...
+ * @returns {string} colorified content ...
+ */
+function applyBackgroundColor(content, color) {
+    //
+    // Validate Arg ...
+    if (!XValueTools.isValidArg(content)) {
+        return content;
+    }
+
+    //
+    let eColor = AVAILABLE_BACKGROUND_COLORS[color];
+    if (eColor === undefined) {
+        return content;
+    }
+
+    //
+    return `${eColor}${content}${AVAILABLE_STYLES.Reset}`;
+}
+
+/**
+ * generate style and color applier expression ...
+ * 
+ * @param {string} color specific color name for using to styling ...
+ * @param {string} style soecufic style name to use ...
+ * @param {boolean} reset close applier string by reset styles ...
+ * @param {boolean} toForeground apply specified color as foreground ...
+ * @param {boolean} toBackground apply specified color as background ...
+ * @returns {string} style and color applier string ...
+ */
+function getApplier(
+    style = "",
+    color = "",
+    reset = false,
+    toForeground = true,
+    toBackground = false
+) {
+    //
+    let result = "";
+
+    //
+    // Detect and Validate Style and Apply it ...
+    let eStyle = AVAILABLE_STYLES[style];
+    if (XValueTools.isValidArg(eStyle)) {
+        result = `${eStyle}`;
+    }
+
+    //
+    // Detect and Validate Foreground Color and Apply it ...
+    let eFColor = AVAILABLE_FOREGROUND_COLORS[color];
+    if (
+        !!toForeground
+        && XValueTools.isValidArg(eFColor)
+    ) {
+        result = `${eFColor}`;
+    }
+
+    //
+    // Detect and Validate Background Color and Apply it ...
+    let eBColor = AVAILABLE_BACKGROUND_COLORS[color];
+    if (
+        !!toBackground
+        && XValueTools.isValidArg(eBColor)
+    ) {
+        result = `${eBColor}`;
+    }
+
+    //
+    if (
+        !!reset &&
+        result.length > 0
+    ) {
+        result = `${result}${AVAILABLE_STYLES.Reset}`;
+    }
+
+    //
+    return result;
+}
+
+/**
+ * generate style applier expression ...
+ * 
+ * @param {string} style soecufic style name to use ...
+ * @param {boolean} reset close applier string by reset styles ...
+ * @returns {string} style applier string ...
+ */
+function getStyleApplier(
+    style = "",
+    reset = false
+) {
+    //
+    let result = "";
+
+    //
+    // Detect and Validate Style and Apply it ...
+    let eStyle = AVAILABLE_STYLES[style];
+    if (XValueTools.isValidArg(eStyle)) {
+        result = `${eStyle}`;
+    }
+
+    //
+    if (
+        !!reset &&
+        result.length > 0
+    ) {
+        result = `${result}${AVAILABLE_STYLES.Reset}`;
+    }
+
+    //
+    return result;
+}
+
+/**
+ * generate color applier expression ...
+ * 
+ * @param {string} color specific color name for using to styling ...
+ * @param {boolean} reset close applier string by reset styles ...
+ * @param {boolean} toForeground apply specified color as foreground ...
+ * @param {boolean} toBackground apply specified color as background ...
+ * @returns {string} color applier string ...
+ */
+function getColorApplier(
+    color = "",
+    reset = false,
+    toForeground = true,
+    toBackground = false
+) {
+    //
+    let result = "";
+
+    //
+    // Detect and Validate Foreground Color and Apply it ...
+    let eFColor = AVAILABLE_FOREGROUND_COLORS[color];
+    if (
+        !!toForeground
+        && XValueTools.isValidArg(eFColor)
+    ) {
+        result = `${eFColor}`;
+    }
+
+    //
+    // Detect and Validate Background Color and Apply it ...
+    let eBColor = AVAILABLE_BACKGROUND_COLORS[color];
+    if (
+        !!toBackground
+        && XValueTools.isValidArg(eBColor)
+    ) {
+        result = `${eBColor}`;
+    }
+
+    //
+    if (
+        !!reset &&
+        result.length > 0
+    ) {
+        result = `${result}${AVAILABLE_STYLES.Reset}`;
+    }
+
+    //
+    return result;
+}
+
+/**
+ * colorified specific content ...
+ * 
+ * @param {string} content specified content for styling ...
+ * @param {string} color specific color name for using to styling ...
+ * @param {boolean} toForeground apply specified color as foreground ...
+ * @param {boolean} toBackground apply specified color as background ...
+ * @returns {string}
+ */
+function colorifyContent(
+    content = "",
+    color = "",
+    toForeground = true,
+    toBackground = false
+) {
+    //
+    let result = content;
+
+    //
+    if (!XValueTools.isValidArg(content)) {
+        return result;
+    }
+
+    //
+    // Finde Colors ...
+
+    //
+    // Detect and Validate Foreground Color and Apply it ...
+    let eFColor = AVAILABLE_FOREGROUND_COLORS[color];
+    if (
+        !!toForeground
+        && XValueTools.isValidArg(eFColor)
+    ) {
+        result = `${eFColor}${result}`;
+    }
+
+    //
+    // Detect and Validate Background Color and Apply it ...
+    let eBColor = AVAILABLE_BACKGROUND_COLORS[color];
+    if (
+        !!toBackground
+        && XValueTools.isValidArg(eBColor)
+    ) {
+        result = `${eBColor}${result}`;
+    }
+
+    //
+    if (
+        result.length > 0
+        && (
+            XValueTools.isValidArg(eFColor) ||
+            XValueTools.isValidArg(eBColor)
+        )
+    ) {
+        result = `${result}${AVAILABLE_STYLES.Reset}`;
+    }
+
+    //
+    return result;
+}
+
+/**
+ * apply style on specific content ...
+ * 
+ * @param {string} content specified content for styling ...
+ * @param {string} style soecufic style name to use ...
+ * @returns {string}
+ */
+function stylifiyContent(
+    content = "",
+    style = "",
+) {
+    //
+    let result = content;
+
+    //
+    if (!XValueTools.isValidArg(content)) {
+        return result;
+    }
+
+    //
+    // Detect and Validate Style and Apply it ...
+    let eStyle = AVAILABLE_STYLES[style];
+    if (XValueTools.isValidArg(eStyle)) {
+        result = `${eStyle}${result}`;
+    }
+
+    //
+    if (
+        result.length > 0
+        && XValueTools.isValidArg(eStyle)
+    ) {
+        result = `${result}${AVAILABLE_STYLES.Reset}`;
+    }
+
+    //
+    return result;
+}
+//#endregion
+
+//
+//#region Module Exports ...
+module.exports = {
+    //
+    STYLE_NAMES,
+    COLOR_NAMES,
+    //
+    apply,
+    applyStyle,
+    getApplier,
+    getColorApplier,
+    getStyleApplier,
+    colorifyContent,
+    stylifiyContent,
+    applyForegroundColor,
+    applyBackgroundColor,
+}
+//#endregion

Documents/JsModules/x-file.tools.js

@@ -0,0 +1,887 @@
+/**
+ * XFile Tools Module ...
+ * a module for handle all file/folder manipulating task in node js ...
+ * 
+ * Maintainer
+ * 
+ * Hadi Khazaee Asl <https://saherelm.ir> (hadi_khazaee_asl@yahoo.com)
+ */
+
+//
+//#region Module Imports ...
+const fs = require('fs');
+const os = require('os');
+const Path = require('path');
+const http = require('http');
+const https = require('https');
+const XValueTools = require('./x-value.tools');
+//#endregion
+
+//
+//#region Constants ...
+/**
+ * current os path separators ...
+ */
+const PathSeparator = Path.sep;
+
+/**
+ * current directory ...
+ */
+const CurrentDir = __dirname;
+//#endregion
+
+//
+//#region Actions ...
+//
+//#region Global ...
+/**
+ * retrieve a path status ...
+ * 
+ * @param {string} path a path value to check ...
+ * @returns an stat object ...
+ */
+function getStatus(path = '') {
+    //
+    if (!XValueTools.isValidArg(path)) {
+        return undefined;
+    }
+
+    //
+    return fs.statSync(path);
+}
+
+/**
+ * retrieve user's Home path ...
+ *
+ * @returns {string} a path ...
+ */
+function getHomePath() {
+    return os.homedir();
+}
+//#endregion
+
+//
+//#region Path ...
+/**
+ * retrieve the base name of specific address path ...
+ * 
+ * @param {string} path address of file or folder ...
+ * @returns string ...
+ */
+function basename(path = '') {
+    //
+    if (!XValueTools.isValidArg(path)) {
+        return '';
+    }
+
+    //
+    const result = Path.basename(path);
+    return result;
+}
+
+/**
+ * join several path segments together ...
+ * 
+ * @param  {...string} path path params ... 
+ * @returns a joined paths ...
+ */
+function joinPath(...path) {
+    return Path.join(...path);
+}
+
+/**
+ * resolve a relative path to absolute ...
+ * 
+ * @param {string[]} path a path value to check ...
+ * @returns {string}
+ */
+function resolvePath(...path) {
+    return Path.resolve(...path);
+}
+//#endregion
+
+//
+//#region File ...
+/**
+ * determines a path destination is a file or not ...
+ * 
+ * @param {string} path a path value to check ...
+ * @returns a boolean value ...
+ */
+function isFileExists(path = '') {
+    //
+    if (!XValueTools.isValidArg(path)) {
+        return false;
+    }
+
+    //
+    try {
+        const stat = getStatus(path);
+        if (!stat) {
+            return false;
+        }
+
+        //
+        return stat.isFile();
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * remove a file ...
+ * 
+ * @param {string} path a file path ...
+ * @returns {Promise<boolean>} action done or not ...
+ */
+function removeFile(path = '') {
+    return new Promise((resolve) => {
+        //
+        if (!isFileExists(path)) {
+            resolve(false);
+        }
+
+        //
+        fs.unlink(path, (err) => {
+            //
+            if (err) {
+                resolve(false);
+                return;
+            }
+
+            //
+            resolve(true);
+        });
+    });
+}
+
+/**
+ * copy a file to destination path ...
+ * 
+ * @param {string} source source file path ...
+ * @param {string} dest dest folder path ...
+ * @returns {Promise<boolean>} action done or not ...
+ */
+function copyFile(
+    source = '',
+    dest = ''
+) {
+    return new Promise((resolve) => {
+        //
+        if (
+            !isFileExists(source) ||
+            !isDirectoryExists(dest)
+        ) {
+            resolve(false);
+            return;
+        }
+
+        //
+        const destFilePath = Path.join(dest, Path.basename(source));
+        fs.copyFile(source, destFilePath, (err) => {
+            //
+            if (err) {
+                resolve(false);
+                return;
+            }
+
+            //
+            resolve(true);
+        });
+    });
+}
+
+/**
+ * reading specified file content ...
+ * 
+ * @param {string} path a file path ...
+ * @returns {Promise<string>} file content ...
+ */
+function readFile(path = '') {
+    return new Promise((resolve) => {
+        //
+        if (!isFileExists(path)) {
+            resolve('');
+            return;
+        }
+
+        //
+        fs.readFile(path, 'utf8', (err, content) => {
+            //
+            if (err) {
+                resolve(undefined);
+                return;
+            }
+
+            //
+            resolve(content);
+        });
+    });
+}
+
+/**
+ * write content to a file ...
+ * 
+ * @param {string} path a file path ...
+ * @param {string} content the content which going to write to the file ...
+ * @param {bool} overwrite determines file overwrite if exists ...
+ * @returns {Promise<boolean>} action done or not ...
+ */
+function writeFile(
+    path = '',
+    content = '',
+    overwrite = true
+) {
+    return new Promise((resolve) => {
+        //
+        if (isFileExists(path) && !overwrite) {
+            //
+            resolve(false);
+            return;
+        }
+
+        //
+        // Normalize Content ...
+        content = XValueTools.isValidArg(content) ?
+            content :
+            '';
+
+        //
+        fs.writeFile(path, content, (err) => {
+            //
+            if (err) {
+                //
+                resolve(false);
+                return;
+            }
+
+            //
+            resolve(true);
+        });
+    });
+}
+
+/**
+ * create a file ...
+ * 
+ * @param {string} path file path ...
+ * @param {string} fileName file name ...
+ * @returns {Promise<boolean>} action done or not ...
+ */
+function createFile(
+    path = '',
+    fileName = ''
+) {
+    return new Promise((resolve) => {
+        //
+        const filePath = Path.join(path, fileName);
+        if (
+            isFileExists(filePath) ||
+            !XValueTools.isValidArg(path) ||
+            !XValueTools.isValidArg(fileName)
+        ) {
+            //
+            resolve(false);
+            return;
+        }
+
+        //
+        fs.writeFile(filePath, '', (err) => {
+            //
+            if (err) {
+                //
+                resolve(false);
+                return;
+            }
+
+            //
+            resolve(true);
+        });
+    });
+}
+
+/**
+ * remove a file name extension ...
+ * 
+ * @param {string} name 
+ * @returns {string} name without extension ... 
+ */
+function removeFileExtension(name = '') {
+    return name.substring(0, name.lastIndexOf('.')) || name;
+}
+
+/**
+ * retrieve a file extension ...
+ * 
+ * @param {string} path a path which locate a file ...
+ * @returns {string}
+ */
+function getFileExtension(path = '') {
+    //
+    let result = "";
+
+    //
+    // Validate Arg ...
+    if (
+        !XValueTools.isValidArg(path)
+        || !isFileExists(path)
+    ) {
+        return result;
+    }
+
+    //
+    // Retrieve just file name ...
+    const fileName = basename(path);
+    result = fileName.replace(
+        removeFileExtension(fileName),
+        ""
+    );
+
+    //
+    return result;
+}
+
+/**
+ * retrieve all files list recursively from specific path ...
+ * 
+ * @param {string} path a source folder path ...
+ * @param {string[]} extensions which file extensions need to be listed, live empty for all files ...
+ * @returns {Promise<string[]>}
+ */
+async function getRecursiveFilesList(
+    path = "",
+    extensions = []
+) {
+    //
+    let result = [];
+
+    //
+    // Validate Args ...
+    if (
+        !XValueTools.isValidArg(path)
+        || !isDirectoryExists(path)
+    ) {
+        return result;
+    }
+
+    //
+    const contents = await getDirectoryContents(path);
+    for (const item of contents) {
+        //
+        const itemPath = joinPath(
+            path,
+            item
+        );
+
+        //
+        const isItemFile = isFileExists(itemPath);
+        if (isItemFile) {
+            //
+            const itemFileExtension = getFileExtension(itemPath);
+            const isFileInSupportedExtensions =
+                extensions === undefined || extensions.length === 0
+                    ? true
+                    : extensions.includes(itemFileExtension)
+                ;
+            if (isFileInSupportedExtensions) {
+                result.push(itemPath);
+            }
+        } else if (isDirectoryExists(itemPath)) {
+            //
+            const itemPathFiles = await getRecursiveFilesList(itemPath, extensions);
+            result.push(...itemPathFiles);
+        }
+    }
+
+    //
+    return result;
+}
+
+/**
+ * Extract Specific files from a folder and it's content ...
+ * 
+ * @param {string} path Folder Path ... 
+ * @returns 
+ */
+async function extractFiles(path = "", ext = [], excludeWorkspaceFolders = []) {
+    //
+    const result = [];
+
+    //
+    if (!ext || ext.length == 0) {
+        return result;
+    }
+
+    //
+    const pathContent = await getDirectoryContents(path);
+    if (!pathContent || pathContent.length == 0) {
+        return result;
+    }
+
+    //
+    // Loop through Content ...
+    for (const c of pathContent) {
+        //
+        // Prepare full path ...
+        const cPath = joinPath(path, c);
+
+        //
+        // check content path is file or not ...
+        const isCFile = isFileExists(cPath);
+        const isCDirectory = isDirectoryExists(cPath);
+        if (isCFile) {
+            //
+            // Check it is MQL file or not ...
+            const cExt = getFileExtension(cPath);
+            if (ext.includes(cExt)) {
+                result.push(cPath);
+            }
+        } else if (isCDirectory) {
+            //
+            const destFolderName = basename(cPath);
+            const isExcluded = excludeWorkspaceFolders.includes(destFolderName);
+            if (isExcluded) {
+                continue;
+            }
+
+            //
+            const cFiles = await extractFiles(cPath, ext);
+            if (cFiles && cFiles.length > 0) {
+                result.push(...cFiles);
+            }
+        }
+    }
+
+    //
+    return result;
+}
+//#endregion
+
+//
+//#region Directory ...
+/**
+ * create a directory ...
+ * 
+ * @param {string} path destination path including dir name ...
+ * @param {boolean} recursive create directories recursively ...
+ * @returns action done or not ...
+ */
+function createDirectory(
+    path = '',
+    recursive = true
+) {
+    //
+    let result = false;
+
+    //
+    if (
+        isDirectoryExists(path) ||
+        !XValueTools.isValidArg(path)
+    ) {
+        return false;
+    }
+
+    //
+    try {
+        //
+        fs.mkdirSync(path, { recursive: recursive });
+        result = true;
+        return result;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * remove a directory ...
+ * 
+ * @param {string} path destination path including dir name ...
+ * @param {boolean} recursive removes directories recursively ...
+ * @returns {Promise<boolean>} action done or not ...
+ */
+function removeDirectory(
+    path = '',
+    recursive = false
+) {
+    return new Promise((resolve) => {
+        //
+        if (!isDirectoryExists(path)) {
+            resolve(false);
+            return;
+        }
+
+        //
+        fs.rm(path, {
+            recursive
+        }, (err) => {
+            //
+            if (err) {
+                resolve(false);
+                return;
+            }
+
+            //
+            resolve(true);
+        });
+    });
+}
+
+/**
+ * determines a path destination is a directory or not ...
+ * 
+ * @param {string} path a folder path ...
+ * @returns represent destnation path is Directory or not ...
+ */
+function isDirectoryExists(path = '') {
+    //
+    if (!XValueTools.isValidArg(path)) {
+        return false;
+    }
+
+    //
+    try {
+        //
+        const isExists = fs.existsSync(path);
+        if (!isExists) {
+            return false;
+        }
+
+        //
+        const stat = getStatus(path);
+        if (!stat) {
+            return false;
+        }
+
+        //
+        const result = stat.isDirectory();
+        return result;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * retrieve a directory content ...
+ * 
+ * @param {string} path a folder path ...
+ * @returns {Promise<string[]>} a collection of folder files ...
+ */
+function getDirectoryContents(path = '') {
+    return new Promise((resolve) => {
+        //
+        if (!isDirectoryExists(path)) {
+            resolve([]);
+            return;
+        }
+
+        //
+        fs.readdir(path, (err, content) => {
+            //
+            if (err) {
+                resolve([]);
+                return;
+            }
+
+            //
+            resolve(content);
+        });
+    });
+}
+
+/**
+ * retrieve a directory files ...
+ * 
+ * @param {string} path a folder path ...
+ * @returns {Promise<string[]>} a collection of folder files ...
+ */
+function getDirectoryFiles(
+    path = '',
+    containsHiddenFiles = false
+) {
+    return new Promise((resolve) => {
+        //
+        if (!isDirectoryExists(path)) {
+            resolve([]);
+            return;
+        }
+
+        //
+        fs.readdir(path, (err, content) => {
+            //
+            if (err) {
+                resolve([]);
+                return;
+            }
+
+            //
+            if (!containsHiddenFiles) {
+                content = content.filter(c => !c.startsWith('.'));
+            }
+
+            //
+            const result = [];
+            content
+                .forEach(c => {
+                    //
+                    const cPath = Path.join(path, c);
+                    if (isFileExists(cPath)) {
+                        result.push(c);
+                    }
+                });
+
+            //
+            resolve(result);
+        });
+    });
+}
+
+/**
+ * retrieve a directory folders ...
+ * 
+ * @param {string} path a folder path ...
+ * @returns {Promise<string[]>} a collection of folder names ...
+ */
+function getDirectoryFolders(path = '') {
+    return new Promise((resolve) => {
+        //
+        if (!isDirectoryExists(path)) {
+            resolve([]);
+            return;
+        }
+
+        //
+        fs.readdir(path, (err, content) => {
+            //
+            if (err) {
+                resolve([]);
+                return;
+            }
+
+            //
+            const result = [];
+            content.forEach(c => {
+                //
+                const cPath = Path.join(path, c);
+                if (isDirectoryExists(cPath)) {
+                    result.push(c);
+                }
+            });
+
+            //
+            resolve(result);
+        });
+    });
+}
+
+/**
+ * copy a folder with all of it's content to dest ...
+ * 
+ * @param {string} source source folder path ...
+ * @param {string} dest dest folder path ...
+ * @returns {Promise<boolean>} action done or not ...
+ */
+async function copyFolder(
+    source = '',
+    dest = ''
+) {
+    //
+    if (
+        !isDirectoryExists(source) ||
+        !XValueTools.isValidArg(dest) ||
+        !XValueTools.isValidArg(source)
+    ) {
+        return false;
+    }
+
+    //
+    const folderName = Path.basename(source);
+    const destPath = Path.join(dest, folderName);
+
+    //
+    // Create Dest Path folder if not exists ...
+    if (!isDirectoryExists(destPath)) {
+        //
+        let result = createDirectory(destPath, true);
+        if (!result) {
+            return false;
+        }
+    }
+
+    //
+    // Files ...
+    const files = await getDirectoryFiles(source);
+    if (files && files.constructor === Array && files.length > 0) {
+        //
+        const filesPromises = files.map(file => copyFile(Path.join(source, file), destPath));
+        const filesResult = (await Promise.all(filesPromises)).every(r => !!r);
+        if (!filesResult) {
+            return false;
+        }
+    }
+
+    //
+    // Folders ...
+    const folders = await getDirectoryFolders(source);
+    if (folders && folders.constructor === Array && folders.length > 0) {
+        //
+        const folderPromises = folders.map(folder => copyFolder(Path.join(source, folder), destPath));
+        const filesResult = (await Promise.all(folderPromises)).every(r => !!r);
+        if (!filesResult) {
+            return false;
+        }
+    }
+
+    //
+    return true;
+}
+//#endregion
+
+//
+//#region Downloader ...
+/**
+ * download a file from specific url and store it ...
+ * 
+ * @param {string} filepath the file name and path which required to put download file on it ...
+ * @param {string} url the web url for downloading ...
+ */
+function download(filepath, url) {
+    //
+    // Validate Args ...
+    if (
+        !XValueTools.isValidArg(url)
+        || !XValueTools.isValidURL(url)
+        || !XValueTools.isValidArg(filepath)
+    ) {
+        return;
+    }
+
+    //
+    var file = fs.createWriteStream(filepath);
+
+    //
+    if (url.startsWith('https:')) {
+        https.get(url, function (response) {
+            response.pipe(file);
+        });
+    } else if (url.startsWith('http:')) {
+        http.get(url, function (response) {
+            response.pipe(file);
+        });
+    }
+}
+//#endregion
+
+//
+//#region JSON ...
+/**
+ * read and parse a JSON content from a file ...
+ * 
+ * @param {string} path source file path ...
+ * @returns {any}
+ */
+function readJSON(path = "") {
+    //
+    // Validate Args ...
+    if (!isFileExists(path)) {
+        return undefined;
+    }
+
+    //
+    let result = undefined;
+    try {
+        result = require(path);
+    } catch {
+        result = undefined;
+    }
+
+    //
+    return result;
+}
+
+/**
+ * write a JSON Object content into a file ...
+ * 
+ * @param {string} path dest file path ...
+ * @param {any} content an object which required to write to file ...
+ * @returns {Promise<boolean>}
+ */
+async function writeJSON(
+    path = "",
+    content = undefined
+) {
+    //
+    let result = false;
+
+    //
+    // Validate Args ...
+    if (!XValueTools.isValidArg(path)) {
+        return result;
+    }
+
+    //
+    // Normallize Content ...
+    if (content === undefined) {
+        content = {};
+    }
+
+    //
+    const contentString = XValueTools.beautifyJSON(content);
+
+    //
+    result = await writeFile(
+        path,
+        contentString,
+        true
+    );
+
+    //
+    return result;
+}
+//#endregion
+//#endregion
+
+//
+//#region Module Exports ...
+module.exports = {
+    //
+    CurrentDir,
+    PathSeparator,
+
+    //
+    getStatus,
+    getHomePath,
+
+    //
+    basename,
+    joinPath,
+    resolvePath,
+
+    //
+    download,
+
+    //
+    readJSON,
+    writeJSON,
+
+    //
+    copyFile,
+    readFile,
+    writeFile,
+    createFile,
+    removeFile,
+    isFileExists,
+    getFileExtension,
+    removeFileExtension,
+    getRecursiveFilesList,
+    extractFiles,
+
+    //
+    copyFolder,
+    createDirectory,
+    removeDirectory,
+    isDirectoryExists,
+    getDirectoryFiles,
+    getDirectoryFolders,
+    getDirectoryContents,
+};
+//#endregion

Documents/JsModules/x-mql-project.tools.js

@@ -0,0 +1,494 @@
+/**
+ * XProject Tools Module ...
+ * a module for handle MQL5 Projects Compile and Packing ...
+ * 
+ * Maintainer
+ * 
+ * Hadi Khazaee Asl <https://saherelm.ir> (hadi_khazaee_asl@yahoo.com)
+ */
+
+//
+// Import Requirements ...
+const execSync = require("child_process").execSync;
+const XFileTools = require("./Documents/JsModules/x-file.tools");
+const XShellTools = require("./Documents/JsModules/x-shell.tools");
+const XColorTools = require("./Documents/JsModules/x-color.tools");
+const XTypeTools = require("./Documents/JsModules/x-type-detector.tools");
+
+//
+// Definitions ...
+const packsPath = XFileTools.joinPath(".", "Packs");
+const workspacePaths = [
+    "Classes", // Required Classes
+    "Experts", // Expert Advisers 
+    "Helpers", // Indicator's Helpers Classes
+    "Indicators", // Required Indicators
+    "Libraries", // Required Libraries
+    "XCATBEA", // XCATBEA Projects ...
+];
+
+//
+//#region Tools ...
+
+/**
+ * Handle Compile and Pack Projects ...
+ * 
+ * @param {string} projectName
+ * @param {string[]} resources 
+ * @param {boolean} forceCleanup
+ * @param {boolean} forceCompileIndicators
+ */
+async function prepareProject(
+    projectName = "",
+    resources = [],
+    forceCleanup = true,
+    forceCompileIndicators = true
+) {
+    //
+    // Check Resources Has Child ...
+    let isValidArgs =
+        resources.length > 0 &&
+        XTypeTools.isArray(resources);
+    if (!isValidArgs) {
+        //
+        // Log ...
+        console.log(
+            XColorTools.applyForegroundColor("Invalid Resource List ...", XColorTools.COLOR_NAMES.Red)
+        );
+    }
+
+    //
+    // Check Project Name is Valid ...
+    isValidArgs =
+        projectName.length > 0 &&
+        XTypeTools.isString(projectName);
+    if (!isValidArgs) {
+        //
+        // Log ...
+        console.log(
+            XColorTools.applyForegroundColor("Empty Project Name ...", XColorTools.COLOR_NAMES.Red)
+        );
+    }
+
+    //
+    // Extract Required to Compile Resources List ...
+    let compileList = await extractResources(resources, true);
+    if (!compileList || compileList.length == 0) {
+        //
+        // Log ...
+        console.log(
+            XColorTools.applyForegroundColor("Resource List Extraction to Compile Failed ...", XColorTools.COLOR_NAMES.Red)
+        );
+
+        //
+        return;
+    }
+
+    //
+    // Compile Resources Files ...
+    for (const f of compileList) {
+        //
+        // Log ...
+        console.log(
+            XColorTools.applyForegroundColor("try to Compile: ", XColorTools.COLOR_NAMES.Yellow),
+            XColorTools.applyForegroundColor(f, XColorTools.COLOR_NAMES.Blue)
+        );
+
+        //
+        await recursiveTriesToCompileFile(f, 0);
+    }
+
+    //
+    // Extract Required to Pack Resources List ...
+    let packList = await extractResources(resources, false);
+    if (!packList || packList.length == 0) {
+        //
+        // Log ...
+        console.log(
+            XColorTools.applyForegroundColor("Resource List Extraction to Pack Failed ...", XColorTools.COLOR_NAMES.Red)
+        );
+
+        //
+        return;
+    }
+
+    //
+    // Prepare Pack Folder Exists ...
+    let isExists = XFileTools.isDirectoryExists(packsPath);
+    if (!isExists) {
+        XFileTools.createDirectory(packsPath);
+    }
+
+    //
+    // Check Folder Exists or not ...
+    // if Exists Remove it ...
+    // Create Project Folder on Packs ...
+    const prjFolderOnPacks = XFileTools.joinPath(packsPath, projectName);
+    isExists = XFileTools.isDirectoryExists(prjFolderOnPacks);
+    if (isExists) {
+        await XFileTools.removeDirectory(prjFolderOnPacks, true);
+    }
+    XFileTools.createDirectory(prjFolderOnPacks);
+
+    //
+    // Loop through Files ...
+    for (const f of packList) {
+        //
+        // Prepare Destination Path ...
+        const fBasePath = XFileTools.basename(f);
+        let fDestPath = f.replace(fBasePath, "");
+        fDestPath = fDestPath.substring(0, fDestPath.length - 1);
+        fDestPath = XFileTools.joinPath(prjFolderOnPacks, fDestPath);
+
+        //
+        const isFDestPathExists = XFileTools.isDirectoryExists(fDestPath);
+        if (!isFDestPathExists) {
+            XFileTools.createDirectory(fDestPath);
+        }
+
+        //
+        // Log ...
+        console.log(
+            XColorTools.applyForegroundColor("try to copy: ", XColorTools.COLOR_NAMES.Yellow),
+            XColorTools.applyForegroundColor(f, XColorTools.COLOR_NAMES.Blue),
+            XColorTools.applyForegroundColor(" to : ", XColorTools.COLOR_NAMES.Yellow),
+            XColorTools.applyForegroundColor(fDestPath, XColorTools.COLOR_NAMES.Magenta)
+        );
+
+        //
+        let result = await XFileTools.copyFile(f, fDestPath);
+        if (result) {
+            //
+            const msg = "copy successfully ...";
+            console.log(
+                XColorTools.applyForegroundColor(msg, XColorTools.COLOR_NAMES.Green)
+            );
+        } else {
+            //
+            const msg = "copy failed ...";
+            console.log(XColorTools.applyForegroundColor(msg, XColorTools.COLOR_NAMES.Red));
+            throw msg;
+        }
+    }
+
+    //
+    // Log ...
+    console.log(
+        XColorTools.applyForegroundColor("Project: ", XColorTools.COLOR_NAMES.Green),
+        XColorTools.applyForegroundColor(projectName, XColorTools.COLOR_NAMES.Yellow),
+        XColorTools.applyForegroundColor(" Compiled and Packed Successfully ...", XColorTools.COLOR_NAMES.Green),
+    );
+
+    //
+    // Cleanup WorkSpace if Provided ...
+    if (forceCleanup) {
+        await cleanupWorkSpace();
+    }
+
+    //
+    // Compile Indicators ...
+    if (forceCompileIndicators) {
+        await compile("Indicators");
+    }
+}
+
+/**
+ * Extract required Files List ...
+ * 
+ * @param {boolean} forCompile
+ * 
+ * @returns Promise<string[]>
+ */
+async function extractResources(
+    resources = [],
+    forCompile = true
+) {
+    //
+    let result = [];
+
+    //
+    // Loop Through Project Resources and Extract Files List to Compile ...
+    for (const resource of resources) {
+        //
+        // Prepare Normalized Resource Path ...
+        let resourcePath = XFileTools.joinPath(".", resource);
+
+        //
+        // Handle Wild Card Resources ...
+        if (resourcePath.endsWith("//*") ||
+            resourcePath.endsWith("\\*")) {
+            //
+            resourcePath = resourcePath.substring(0, resourcePath.length - 2);
+            const files = await XFileTools.extractFiles(
+                resourcePath,
+                forCompile ? [".mq5", ".mq4"] : [".ex5", ".ex4"]
+            );
+
+            //
+            result = result.concat(files);
+        }
+        //
+        // Handle Direct File Resources ...
+        else {
+            //
+            // Check MQL 5 Version ...
+            let fileResourcePath = resourcePath + (forCompile ? ".mq5" : ".ex5");
+
+            //
+            // Check File Exists ...
+            let isExists = XFileTools.isFileExists(fileResourcePath);
+            if (!isExists) {
+                //
+                // Check MQL 4 Version ...
+                fileResourcePath = resourcePath + (forCompile ? ".mq4" : ".ex4");
+                isExists = XFileTools.isFileExists(fileResourcePath);
+            }
+
+            //
+            // Add File Path to Files List if Exists ...
+            if (isExists) {
+                result.push(fileResourcePath);
+            }
+        }
+    }
+
+    //
+    return result;
+}
+
+/**
+ * try to compile a file ...
+ * @param {string} f 
+ * @param {number} numberOfTries 
+ */
+async function recursiveTriesToCompileFile(f = "", numberOfTries = 0) {
+    //
+    let result = await handleFileCompile(f);
+    if (result) {
+        //
+        const msg = "compiled successfully ...";
+        console.log(XColorTools.applyForegroundColor(msg, XColorTools.COLOR_NAMES.Green));
+        return result;
+    } else {
+        //
+        if (numberOfTries < 10) {
+            //
+            numberOfTries++;
+
+            //
+            const msg = "retry (" + (numberOfTries + 1) + ") ...";
+            console.log(XColorTools.applyForegroundColor(msg, XColorTools.COLOR_NAMES.LightMagenta));
+            await recursiveTriesToCompileFile(f, numberOfTries);
+        } else {
+            //
+            const msg = "failed ...";
+            console.log(XColorTools.applyForegroundColor(msg, XColorTools.COLOR_NAMES.Red));
+            throw msg;
+
+            //
+            return false;
+        }
+    }
+}
+
+/**
+ * execute compile task on Specific File ...
+ * @param {string} f file path to Execute Compile task ...
+ * @returns 
+ */
+async function handleFileCompile(f = "") {
+    //
+    let result = false;
+
+    //
+    let exResult = await compileMQLFile(f);
+    if (exResult.includes("0 errors")) {
+        result = true;
+    } else {
+        result = false;
+    }
+
+    //
+    return result;
+}
+
+/**
+ * Compile Specific MQL File ...
+ * 
+ * @param {string} path MQL file path ...
+ * @returns 
+ */
+async function compileMQLFile(path = "") {
+    //
+    // Check File Exists ...
+    const isExists = XFileTools.isFileExists(path);
+    if (!isExists) {
+        //
+        const msg = "file not found ...";
+        console.log(XColorTools.applyForegroundColor(msg, XColorTools.COLOR_NAMES.Red));
+        throw msg;
+    }
+
+    //
+    const ext = XFileTools.getFileExtension(path);
+    if (ext !== ".mq5" && ext !== "mq4") {
+        //
+        const msg = "invalid file extension ...";
+        console.log(XColorTools.applyForegroundColor(msg, XColorTools.COLOR_NAMES.Red));
+        throw msg;
+    }
+
+    //
+    const cwd = __dirname;
+    const cmd = "compile.cmd " + path;
+
+    //
+    const result = await XShellTools.execute(cmd, cwd);
+    return result;
+}
+
+/**
+ * Run Specified Command in workspace ...
+ * 
+ * @param {string} cmd 
+ * @returns 
+ */
+async function runCommand(cmd = "") {
+    //
+    // Validate Args ...
+    let isValidArgs = cmd.length > 0 &&
+        XTypeTools.isString(cmd);
+
+    //
+    // Validate Commands ...
+    if (isValidArgs) {
+        //
+        // Check Available Commands ...
+        isValidArgs =
+            cmd === "*" ||
+            cmd === "cleanup" ||
+            workspacePaths.includes(cmd) ||
+            workspacePaths.map(x => x.toLowerCase(x)).includes(cmd.toLowerCase());
+    }
+    if (!isValidArgs) {
+        //
+        // Log ...
+        console.log(
+            XColorTools.applyForegroundColor("Invalid Command ...", XColorTools.COLOR_NAMES.Red)
+        );
+    }
+
+    //
+    // Compile ...
+    if (cmd == "*") {
+        await compileWorkSpace();
+    } else if (cmd == "cleanup") {
+        await cleanupWorkSpace();
+    } else {
+        //
+        // Select Workspace to Compile ...
+        const folder = workspacePaths
+            .find(x => x.toLowerCase() === cmd.toLowerCase());
+        isValidArgs =
+            XTypeTools.isString(folder) &&
+            folder.length > 0;
+        if (!isValidArgs) {
+            //
+            // Log ...
+            console.log(
+                XColorTools.applyForegroundColor("Invalid Command ...", XColorTools.COLOR_NAMES.Red)
+            );
+        }
+
+        //
+        // Extract Required to Compile Resources List ...
+        let compileList = await XFileTools.extractFiles(
+            folder,
+            [".mq5", ".mq4"]
+        );
+        if (!compileList || compileList.length == 0) {
+            //
+            // Log ...
+            console.log(
+                XColorTools.applyForegroundColor("Extraction to Compile Failed ...", XColorTools.COLOR_NAMES.Red)
+            );
+
+            //
+            return;
+        }
+
+        //
+        // Compile Resources Files ...
+        for (const f of compileList) {
+            //
+            // Log ...
+            console.log(
+                XColorTools.applyForegroundColor("try to Compile: ", XColorTools.COLOR_NAMES.Yellow),
+                XColorTools.applyForegroundColor(f, XColorTools.COLOR_NAMES.Blue)
+            );
+
+            //
+            await recursiveTriesToCompileFile(f, 0);
+        }
+    }
+}
+
+/**
+ * Cleanup Workspace compiled files ...
+ */
+async function cleanupWorkSpace() {
+    //
+    for (const path of workspacePaths) {
+        //
+        const fSourcePath = XFileTools.joinPath(".", path);
+        const filesToRemove = await XFileTools.extractFiles(fSourcePath, [".ex5", ".ex4"]);
+        for (const f of filesToRemove) {
+            //
+            // Log ...
+            console.log(
+                XColorTools.applyForegroundColor("try to Remove: ", XColorTools.COLOR_NAMES.Yellow),
+                XColorTools.applyForegroundColor(f, XColorTools.COLOR_NAMES.Blue)
+            );
+
+            //
+            let result = await XFileTools.removeFile(f);
+            if (result) {
+                //
+                const msg = "removed successfully ...";
+                console.log(
+                    XColorTools.applyForegroundColor(msg, XColorTools.COLOR_NAMES.Green)
+                );
+            } else {
+                //
+                const msg = "removed failed ...";
+                console.log(XColorTools.applyForegroundColor(msg, XColorTools.COLOR_NAMES.Red));
+                throw msg;
+            }
+        }
+    }
+}
+
+/**
+ * Compile Workspace ...
+ */
+async function compileWorkSpace() {
+    //
+    for (const path of workspacePaths) {
+        await runCommand(path);
+    }
+}
+//#endregion
+
+//
+//#region Module Exports ...
+module.exports = {
+    extractResources,
+    recursiveTriesToCompileFile,
+    handleFileCompile,
+    compileMQLFile,
+    runCommand,
+    cleanupWorkSpace,
+    compileWorkSpace,
+    prepareProject
+}
+//#endregion

Documents/JsModules/x-shell.tools.js

@@ -0,0 +1,219 @@
+/**
+ * XShell Tools Module ...
+ * a module for handling shell actions and retrieve OS Info in node js ...
+ * 
+ * Maintainer
+ * 
+ * Hadi Khazaee Asl <https://saherelm.ir> (hadi_khazaee_asl@yahoo.com)
+ */
+
+//
+//#region Imports ...
+const os = require('os');
+const process = require('process');
+const { exec } = require("child_process");
+const XFileTools = require('./x-file.tools');
+//#endregion
+
+//
+//#region Constants ...
+//
+const OS = {
+    Aix: 'aix',
+    Darwin: 'darwin',
+    FreeBSD: 'freebsd',
+    Linux: 'linux',
+    OpenBSD: 'openbsd',
+    SnOS: 'sunos',
+    Windows: 'win32'
+};
+
+//
+const isWindows = process.platform === OS.Windows;
+//#endregion
+
+//
+//#region Actions ...
+//
+//#region Pure shell commands ...
+/**
+ * execute a command using NodeJS on shell ...
+ * 
+ * @param {string} cmd command to execute ...
+ * @param {string} cwd working directory ...
+ * 
+ * @returns Promise<any, errr> instance ...
+ */
+function execute(cmd, cwd) {
+    return new Promise((resolve, reject) => {
+        //
+        if (!cmd || cmd.toString().length === 0 || (cwd && !XFileTools.isDirectoryExists(cwd))) {
+            reject('invalid args ...');
+            return;
+        }
+
+        //
+        exec(cmd, { cwd }, (err, result, stdError) => {
+            //
+            if (err) {
+                reject(err);
+                return;
+            }
+
+            //
+            if (stdError) {
+                //
+                // reject(stdError);
+                // return;
+            }
+
+            //
+            resolve(result);
+        });
+    });
+};
+
+/**
+ * determines a command exists on host or not ...
+ * 
+ * @param {string} name specific command name ...
+ * 
+ * @returns boolean Promise ...
+ */
+function checkCommandExists(name) {
+    return new Promise(resolve => {
+        //
+        if (!name) {
+            resolve(false);
+            return;
+        }
+
+        //
+        const cmd = isWindows ? `${name} >nul 2>&1` : `type ${name} >/dev/null 2>&1`;
+        execute(cmd).then(result => {
+            resolve(true);
+        })
+            .catch(err => {
+                resolve(false);
+            });
+    });
+}
+//#endregion
+
+//
+//#region required commands state ...
+/**
+ * check al required commands exists or not ...
+ * 
+ * @returns 
+ */
+async function isRequiredCommandsExists() {
+    //
+    let result = false;
+
+    //
+    // const isTarExists = await isTarCommandExists();
+    // const isCatExists = await isCatCommandExists();
+    // const isGrepExists = await isGrepCommandExists();
+    // const isSedExists = await isSedCommandExists();
+    const isNpmExists = await isNpmCommandExists();
+    const isNgExists = await isNgCommandExists();
+    const isIonicExists = await isIonicCommandExists();
+    const isCordovaExists = await isCordovaCommandExists();
+
+    //
+    result = isNpmExists
+        && isNgExists
+        && isIonicExists
+        && isCordovaExists
+        ;
+
+    //
+    return result;
+}
+
+/**
+ * retrieve required commands state object ...
+ * 
+ * @returns 
+ */
+async function getRequiredCommandsStates() {
+    //
+    const result = {};
+
+    //
+    // const isTarExists = await isTarCommandExists();
+    // const isCatExists = await isCatCommandExists();
+    // const isGrepExists = await isGrepCommandExists();
+    // const isSedExists = await isSedCommandExists();
+    const isNpmExists = await isNpmCommandExists();
+    const isNgExists = await isNgCommandExists();
+    const isIonicExists = await isIonicCommandExists();
+    const isCordovaExists = await isCordovaCommandExists();
+
+    //
+    result['npm'] = isNpmExists;
+    result['ng'] = isNgExists;
+    result['ionic'] = isIonicExists;
+    result['cordova'] = isCordovaExists;
+
+    //
+    return result;
+}
+//#endregion
+
+//
+//#region Commonly used Command Checkers ...
+/**
+ * determines npm command exists or not ...
+ * 
+ * @returns 
+ */
+function isNpmCommandExists() {
+    return checkCommandExists('npm');
+}
+
+/**
+ * determines ng command exists or not ...
+ * 
+ * @returns 
+ */
+function isNgCommandExists() {
+    return checkCommandExists('ng');
+}
+
+/**
+ * determines ionic command exists or not ...
+ * 
+ * @returns 
+ */
+function isIonicCommandExists() {
+    return checkCommandExists('ionic');
+}
+
+/**
+ * determines cordova command exists or not ...
+ * 
+ * @returns 
+ */
+function isCordovaCommandExists() {
+    return checkCommandExists('cordova');
+}
+//#endregion
+//#endregion
+
+//
+//#region Module Exports ...
+module.exports = {
+    //
+    execute,
+    checkCommandExists,
+    isRequiredCommandsExists,
+    getRequiredCommandsStates,
+
+    //
+    isNgCommandExists,
+    isIonicCommandExists,
+    isCordovaCommandExists,
+}
+//#endregion

Documents/JsModules/x-type-detector.tools.js

@@ -0,0 +1,268 @@
+/**
+ * DataType Tools Module ...
+ * a module for manipulate and detect supported data types in node js ...
+ * 
+ * Maintainer
+ * 
+ * Hadi Khazaee Asl <https://saherelm.ir> (hadi_khazaee_asl@yahoo.com)
+ */
+
+//
+//#region Constants ...
+/**
+ * all supported data types ...
+ */
+const DataTypes = {
+    Null: 'null',
+    Date: 'date',
+    Array: 'array',
+    Object: 'object',
+    String: 'string',
+    Number: 'number',
+    Unknown: 'unknown',
+    Boolean: 'boolean',
+    Function: 'function',
+    Undefined: 'undefined',
+};
+//#endregion
+
+//
+//#region Actions ...
+/**
+ * detect type of a content ...
+ * 
+ * @param {any} value the content which going to check ...
+ * @returns 
+ */
+function getType(value) {
+    //
+    const type = typeof value;
+
+    //
+    let result = DataTypes.Unknown;
+    let dateIdentifier = '[object Date]';
+    let constructor = value && value.constructor ?
+        value.constructor.toString() :
+        '';
+
+    //
+    switch (type) {
+        //
+        case 'undefined':
+            result = DataTypes.Undefined;
+            break;
+
+        //
+        case 'boolean':
+            result = DataTypes.Boolean;
+            break;
+
+        //
+        case 'string':
+            result = DataTypes.String;
+            break;
+
+        //
+        case 'number':
+            result = DataTypes.Number;
+            break;
+
+        //
+        case 'function':
+            result = DataTypes.Function;
+            break;
+
+        //
+        case 'object':
+            //
+            // Null ...
+            if (value === null) {
+                result = DataTypes.Null;
+            } else
+                //
+                // Array ...
+                if (Array.isArray(value)) {
+                    result = DataTypes.Array;
+                } else
+                    //
+                    // Data ...
+                    if (
+                        value instanceof Date ||
+                        isFunction(value.getMonth) ||
+                        constructor.includes(dateIdentifier) ||
+                        Object.prototype.toString.call(value) === dateIdentifier
+                    ) {
+                        result = DataTypes.Date;
+                    } else
+                    //
+                    // Object ...
+                    {
+                        result = DataTypes.Object;
+                    }
+            break;
+
+        //
+        default:
+            result = DataTypes.Unknown;
+            break;
+    }
+
+    //
+    return result;
+}
+
+/**
+ * retrieve an object constructor ...
+ * 
+ * @param {any} value the content which going to check ...
+ * @returns 
+ */
+function getConstructor(value) {
+    //
+    const result = value && value.constructor ?
+        value.constructor.toString() :
+        '';
+
+    //
+    return result;
+}
+
+/**
+ * retrieve an object prototype ...
+ * 
+ * @param {any} value the content which going to check ...
+ * @returns 
+ */
+function getPrototype(value) {
+    //
+    const result = value ?
+        Object.prototype.toString.call(value) :
+        '';
+
+    //
+    return result;
+}
+
+/**
+ * check an object is null or not ...
+ * 
+ * @param {any} value the content which going to check ...
+ * @returns 
+ */
+function isNull(value) {
+    return getType(value) === DataTypes.Null;
+}
+
+/**
+ * check an object is undefined or not ...
+ * 
+ * @param {any} value the content which going to check ...
+ * @returns 
+ */
+function isUndefined(value) {
+    return getType(value) === DataTypes.Undefined;
+}
+
+/**
+ * check an object is null or undefined or not ...
+ * 
+ * @param {any} value the content which going to check ...
+ * @returns 
+ */
+function isNullOrUndefined(value) {
+    return isNull(value) || isUndefined(value);
+}
+
+/**
+ * check an object is a date or not ...
+ * 
+ * @param {any} value the content which going to check ...
+ * @returns 
+ */
+function isDate(value) {
+    return getType(value) === DataTypes.Date;
+}
+
+/**
+ * check an object is number or not ...
+ * 
+ * @param {any} value the content which going to check ...
+ * @returns 
+ */
+function isNumber(value) {
+    return getType(value) === DataTypes.Number;
+}
+
+/**
+ * check an object is string or not ...
+ * 
+ * @param {any} value the content which going to check ...
+ * @returns 
+ */
+function isString(value) {
+    return getType(value) === DataTypes.String;
+}
+
+/**
+ * check an object is boolean or not ...
+ * 
+ * @param {any} value the content which going to check ...
+ * @returns 
+ */
+function isBoolean(value) {
+    return getType(value) === DataTypes.Boolean;
+}
+
+/**
+ * check an object is an Array or not ...
+ * 
+ * @param {any} value the content which going to check ...
+ * @returns 
+ */
+function isArray(value) {
+    return getType(value) === DataTypes.Array;
+}
+
+/**
+ * check an object is and Object or not ...
+ * 
+ * @param {any} value the content which going to check ...
+ * @returns 
+ */
+function isObject(value) {
+    return getType(value) === DataTypes.Object;
+}
+
+/**
+ * check an object is a Function or not ...
+ * 
+ * @param {any} value the content which going to check ...
+ * @returns 
+ */
+function isFunction(value) {
+    return getType(value) === DataTypes.Function;
+}
+//#endregion
+
+//
+//#region Module Exports ...
+module.exports = {
+    //
+    DataTypes,
+
+    //
+    getType,
+    getConstructor,
+    getPrototype,
+    isNull,
+    isUndefined,
+    isNullOrUndefined,
+    isDate,
+    isNumber,
+    isString,
+    isBoolean,
+    isArray,
+    isObject,
+    isFunction,
+}
+//#endregion

XCATBEA/Classes/xcatbea.expert.class.mq5

@@ -1959,7 +1959,7 @@ class XCXCATBEAExpert : public XCBase
             //
             // Provider Name ...
             iSignallerInputs.period = _Period;
-            iSignallerInputs.allowDraws = true;
+            iSignallerInputs.allowDraws = false;
             iSignallerInputs.provider = "XTRGB";
             iSignallerInputs.allowGuards = eaAllowGuards;
             iSignallerInputs.riskToRewardRatio = eaSignalR2R;