@eui/tools 5.0.0-rc.8 → 5.1.1

package/scripts/utils/tools.js

@@ -16,6 +16,7 @@ const eol = require('eol');
 const execa = require('execa');
 const replace = require('replace-in-file');
 const xml2js = require('xml2js');
+const moment = require('moment');
 
 const isTestRunning = process.env._TEST;
 
@@ -38,41 +39,89 @@ function runScript(_args, cwdFolder) {
     });
 }
 
+function getPackages(rootFolder) {
+    if (!rootFolder) {
+        rootFolder = 'src/packages';
+    }
+    logInfo('-- Getting packages from ' + rootFolder);
+
+    const packages = fs.readdirSync(rootFolder)
+                       .filter(name => fs.lstatSync(path.resolve(rootFolder, name)).isDirectory())
+                       .map(name => {
+                           return { 'package': name }
+                       });
+
+    if (packages.length === 0) {
+        logInfo('----> no packages found');
+    } else {
+        logInfo('----> packages found : ' + packages.map(p => p.package));
+    }
+    return packages;
+}
+
+function getArgs() {
+  const argv = require('yargs').argv;
+
+  const processArgs = process.env._CSDR_ARGS;
+
+  let args = {};
+
+  if (processArgs) {
+    processArgs.split(',').forEach((item) => {
+      const itemSplit = item.split(':');
+      args[itemSplit[0].trim()] = itemSplit[1].trim();
+    })
+  }
+
+  return {
+    root: argv._[0],
+    ...argv,
+    ...args
+  }
+}
+
+
+
+
+/* -------------------------------------------------------------------------------------------
+**  FILES OPERATIONS
+** ------------------------------------------------------------------------------------------- */
+
 // TODO DETECT if folder exists, otherwise it's exiting without continuing the promise chain
 function relativeCopy(fileGlob, from, to) {
-    return new Promise((resolve, reject) => {
-        glob(fileGlob, { cwd: from, nodir: true, follow: true, dot: true }, (err, files) => {
-            if (err) {
-              logError(err);
-              reject(err);
-            }
-            files.forEach(file => {
-                const origin = path.join(from, file);
-                const dest = path.join(to, file);
-                _recursiveMkDir(path.dirname(dest));
-                fse.copy(origin, dest);
-                resolve();
-            })
-        })
-    });
+  return new Promise((resolve, reject) => {
+      glob(fileGlob, { cwd: from, nodir: true, follow: true, dot: true }, (err, files) => {
+          if (err) {
+            logError(err);
+            reject(err);
+          }
+          files.forEach(file => {
+              const origin = path.join(from, file);
+              const dest = path.join(to, file);
+              _recursiveMkDir(path.dirname(dest));
+              fse.copy(origin, dest);
+              resolve();
+          })
+      })
+  });
 }
 
 function relativeCopyEol(fileGlob, from, to) {
-    return new Promise((resolve, reject) => {
-        glob(fileGlob, { cwd: from, nodir: true, follow: true, dot: true }, (err, files) => {
-            if (err) reject(err);
-            files.forEach(file => {
-                const origin = path.join(from, file);
-                const dest = path.join(to, file);
-                _recursiveMkDir(path.dirname(dest));
-                //fse.copy(origin, dest);
-                const content = fs.readFileSync(origin, { encoding: 'utf8' });
-                const contentToCRLF = eol.crlf(content);
-                fs.writeFileSync(dest, contentToCRLF);
-                resolve();
-            })
-        })
-    });
+  return new Promise((resolve, reject) => {
+      glob(fileGlob, { cwd: from, nodir: true, follow: true, dot: true }, (err, files) => {
+          if (err) reject(err);
+          files.forEach(file => {
+              const origin = path.join(from, file);
+              const dest = path.join(to, file);
+              _recursiveMkDir(path.dirname(dest));
+              //fse.copy(origin, dest);
+              const content = fs.readFileSync(origin, { encoding: 'utf8' });
+              const contentToCRLF = eol.crlf(content);
+              fs.writeFileSync(dest, contentToCRLF);
+              resolve();
+          })
+      })
+  });
 }
 
 function copydir(from, to, overwrite = true, globPattern = '**/*') {
@@ -87,15 +136,15 @@ function copydir(from, to, overwrite = true, globPattern = '**/*') {
 }
 
 function rmdir(path) {
-    logInfo('----> path exists ' + path);
-    try {
-        if (isWindows()) {
-            fs.rmdirSync(path);
-        } else {
-            fs.unlinkSync(path);
-        }
-    } catch(e) {
-    }
+  logInfo('----> remiving ' + path);
+  try {
+      if (isWindows()) {
+          fs.rmdirSync(path);
+      } else {
+          fs.unlinkSync(path);
+      }
+  } catch(e) {
+  }
 }
 
 function rimraf(inputPath) {
@@ -108,14 +157,21 @@ function rimraf(inputPath) {
 }
 
 function rmdirFull(dirPath, removeSelf) {
-    try {
-        if (removeSelf === undefined)
+  try {
+      if (removeSelf === undefined) {
         removeSelf = true;
-        try { var files = fse.readdirSync(dirPath); }
-        catch(e) {
-            return;
-        }
-        if (files.length > 0)
+      }
+
+      try {
+        var files = fse.readdirSync(dirPath);
+      }
+      catch(e) {
+        this.logWarning('Error trying to read folder files');
+        console.log(e);
+        return;
+      }
+
+      if (files.length > 0) {
         for (var i = 0; i < files.length; i++) {
             var filePath = path.join(dirPath, files[i]);
             if (fse.statSync(filePath).isFile())
@@ -123,32 +179,38 @@ function rmdirFull(dirPath, removeSelf) {
             else
             rmdir(filePath);
         }
-        if (removeSelf)
+      }
+
+      if (removeSelf) {
         fse.rmdirSync(dirPath);
-    }
-    catch(e) {
-        return;
-    }
-  };
+      }
+  }
+
+  catch(e) {
+    this.logWarning('Error trying to remove folder content');
+    console.log(e);
+    return;
+  }
+};
 
 function mkdir(path) {
-    if (!fs.existsSync(path)) {
-        fs.mkdirSync(path);
-    }
+  if (!fs.existsSync(path)) {
+      fs.mkdirSync(path);
+  }
 }
 
 function mkdirRecursive(path) {
-    if (!fs.existsSync(path)) {
-        _recursiveMkDir(path);
-    }
+  if (!fs.existsSync(path)) {
+      _recursiveMkDir(path);
+  }
 }
 
 function isDirExists(path) {
-    try {
-        return fs.statSync(path).isDirectory();
-    } catch (err) {
-        return false;
-    }
+  try {
+      return fs.statSync(path).isDirectory();
+  } catch (err) {
+      return false;
+  }
 }
 
 function isDirEmpty(path) {
@@ -167,52 +229,22 @@ function isDirEmpty(path) {
 }
 
 function isFileExists(path) {
-    try {
-        return fs.statSync(path);
-    } catch (err) {
-        return false;
-    }
+  try {
+      return fs.statSync(path);
+  } catch (err) {
+      return false;
+  }
 }
 
 function link(src, target) {
-    rmdir(target);
-    if (isWindows()) {
-        execSync(`mklink /D ${target} ${src}`);
-    } else {
-        execSync(`ln -s ${src} ${target}`);
-    }
-}
-
-function isWindows() {
-    if (path.sep === "\\") {
-        return true;
-    } else {
-        return false;
-    }
-}
-
-function getPackages(rootFolder) {
-    if (!rootFolder) {
-        rootFolder = 'src/packages';
-    }
-    logInfo('-- Getting packages from ' + rootFolder);
-
-    const packages = fs.readdirSync(rootFolder)
-                       .filter(name => fs.lstatSync(path.resolve(rootFolder, name)).isDirectory())
-                       .map(name => {
-                           return { 'package': name }
-                       });
-
-    if (packages.length === 0) {
-        logInfo('----> no packages found');
-    } else {
-        logInfo('----> packages found : ' + packages.map(p => p.package));
-    }
-    return packages;
+  rmdir(target);
+  if (isWindows()) {
+      execSync(`mklink /D ${target} ${src}`);
+  } else {
+      execSync(`ln -s ${src} ${target}`);
+  }
 }
 
-
-// Recursively create a dir.
 function _recursiveMkDir(dir) {
     if (!fs.existsSync(dir)) {
         _recursiveMkDir(path.dirname(dir));
@@ -324,6 +356,101 @@ function mkdirFilePath(filename) {
   }
 }
 
+function replaceInFile(file, fromString, toString) {
+  const fromRegExp = new RegExp(fromString, 'g');
+
+  logInfo('replace in file: ' + file);
+
+  return new Promise((resolve, reject) => {
+    replace({
+      files: file,
+      from: fromRegExp,
+      to: toString,
+      disableGlobs: true,
+    }, function (err, response) {
+      if (err) {
+        return reject(err);
+      } else {
+        return resolve(response);
+      }
+    })
+  })
+}
+
+function replaceInPath(rootPath, fromString, toString) {
+  const fromRegExp = new RegExp(fromString, 'g');
+
+  return replace.sync({
+    files: [rootPath + '/**/*.*'],
+    from: fromRegExp,
+    to: toString,
+  });
+}
+
+function getXMLJsContent(file) {
+  const content = fs.readFileSync(file, { encoding: 'utf8' });
+
+  var output;
+  xml2js.parseString(content, function (err, result) {
+    output = result;
+  });
+
+  return output;
+}
+
+function getFolders(parentPath) {
+  if (isDirExists(parentPath)) {
+    return fs.readdirSync(parentPath).filter(f => fs.statSync(path.join(parentPath, f)).isDirectory());
+  } else {
+    return [];
+  }
+}
+
+function getFiles(parentPath) {
+  return fs.readdirSync(parentPath).filter(f => fs.statSync(path.join(parentPath, f)).isFile());
+}
+
+function getFilesGlob(from, fileGlob) {
+  return new Promise((resolve, reject) => {
+    glob(fileGlob, { cwd: from, nodir: true, follow: true, dot: true }, (err, files) => {
+        if (err) {
+          logError(err);
+          reject(err);
+        }
+        return resolve(files);
+    })
+  });
+}
+
+function removeFilesExtension(rootPath, extension) {
+  return new Promise((resolve, reject) => {
+    glob(rootPath + "/**/*" + extension,
+      function (err, files) {
+        if (err) {
+          return reject(err);
+        } else {
+          var processed = 0;
+          files.forEach(function (file) {
+            const dir = path.dirname(file);
+            const filename = path.basename(file);
+            // logInfo('remove extention for file : ' + filename + ' in ' + dir);
+            const filenameUpdate = filename.substr(0, filename.indexOf(extension));
+            fs.renameSync(file, dir + "/" + filenameUpdate);
+            processed++;
+          });
+          logInfo(processed + " files processed");
+          resolve();
+        }
+      });
+  })
+}
+
+
+
+/* -------------------------------------------------------------------------------------------
+**  STRING and ARRAY
+** ------------------------------------------------------------------------------------------- */
+
 function capitalizeFirstLetter(string) {
     return string.charAt(0).toUpperCase() + string.slice(1);
 }
@@ -349,6 +476,77 @@ function camelCaseString(string, separator, first) {
     return result;
 }
 
+function replaceAll(str, find, replace) {
+  return str.replace(new RegExp(find, 'g'), replace);
+}
+
+function compareValues(key, order='asc') {
+  return function(a, b) {
+    if(!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) {
+        return 0;
+    }
+
+    const varA = (typeof a[key] === 'string') ?
+      a[key].toUpperCase() : a[key];
+    const varB = (typeof b[key] === 'string') ?
+      b[key].toUpperCase() : b[key];
+
+    let comparison = 0;
+    if (varA > varB) {
+      comparison = 1;
+    } else if (varA < varB) {
+      comparison = -1;
+    }
+    return (
+      (order == 'desc') ? (comparison * -1) : comparison
+    );
+  };
+}
+
+function sortArray(arr, key, order) {
+  return arr.sort(compareValues(key, order));
+}
+
+function removeArrayDuplicates(myArr, prop) {
+  return myArr.filter((obj, pos, arr) => {
+    if (prop) {
+      return arr.map(mapObj => mapObj[prop]).indexOf(obj[prop]) === pos;
+    } else {
+      return arr.map(mapObj => mapObj).indexOf(obj) === pos;
+    }
+  });
+}
+
+function getArraySum(myArr, prop) {
+  return myArr.reduce((prev, cur) => {
+    return prev + cur[prop];
+  }, 0);
+}
+
+function splitNpmPkg(npmPkg) {
+  const scope = npmPkg.substr(0, npmPkg.indexOf('/'));
+  const name = npmPkg.substr(npmPkg.indexOf('/') + 1);
+
+  return { scope: scope, name: name };
+}
+
+
+
+
+
+
+
+/* -------------------------------------------------------------------------------------------
+**  SYSTEM
+** ------------------------------------------------------------------------------------------- */
+function isWindows() {
+  if (path.sep === "\\") {
+      return true;
+  } else {
+      return false;
+  }
+}
+
 function getSysConfig() {
     logInfo('Getting system infos...');
 
@@ -358,11 +556,6 @@ function getSysConfig() {
 
     infos.node = semver.clean(node);
 
-    try {
-        infos.npm = execSync('npm -v').toString().trim();
-    } catch(e) {
-        infos.npm = null;
-    }
     try {
         infos.yarn = execSync('yarn -v').toString().trim();
     } catch(e) {
@@ -372,9 +565,6 @@ function getSysConfig() {
     infos.httpsProxy = execSync('npm config get https-proxy').toString().trim();
     const registry = execSync('npm config get registry').toString().trim();
 
-    infos.isRegistryDiplazium = registry.indexOf('diplazium') >= 0;
-    infos.isRegistryEcDevops = registry.indexOf('ecdevops.eu') >= 0;
-
     logSuccess();
 
     return infos;
@@ -384,9 +574,8 @@ function isSysConfigValid() {
     const infos = getSysConfig();
 
     const validVersions = {
-        node: '>=8.x',
-        npmMaxDiplazium : '<=4.6.1',
-    }
+        node: '>=12.20.x',
+    };
 
     logTitle('Checking system infos...');
 
@@ -395,29 +584,31 @@ function isSysConfigValid() {
         return false;
     }
 
-    if (infos.isRegistryDiplazium && !semver.satisfies(infos.npm, validVersions.npmMaxDiplazium) && infos.yarn === null) {
-        logError(`---> Invalid NPM version when used against diplazium : found:${infos.npm} - required:${validVersions.npmMaxDiplazium}`);
-        logError('------> you can only use NPM 5.x and above if YARN is used as your dependency manager ===> Yarn NOT INSTALLED');
-        return false;
-    }
-
-    if (infos.isRegistryDiplazium && infos.httpsProxy === 'undefined') {
-        logError('---> No proxy setting set when used against diplazium registry');
-        logError('------> check eUI documentation on how to configure your proxy setting');
-        return false;
-    }
-
     logSuccess();
 
     return true;
 }
 
-function replaceAll(str, find, replace) {
-  return str.replace(new RegExp(find, 'g'), replace);
-}
 
 
 
+
+
+
+/* -------------------------------------------------------------------------------------------
+**  LOGGING
+** ------------------------------------------------------------------------------------------- */
+
+function logBigTitle(text) {
+  console.log('\n\n');
+  console.log(
+    chalk.yellow(
+      figlet.textSync(text, { horizontalLayout: 'full' })
+    )
+  );
+  console.log('\n');
+}
+
 const logTitle = (msg) => {
   log(msg, 0);
 }
@@ -434,195 +625,107 @@ const logSuccess = (msg) => {
 const logError = (msg) => {
   log(msg, 3);
 }
+const logErrorTrace = (filename, method, e) => {
+  log(`ERROR in ${filename}`, 3);
+  log(`...method : ${method}`, 3);
+  log(`...message : ${e.message}`, 3);
+}
 
 const logWarning = (msg) => {
   log(msg, 4);
 }
 
+const logAccent = (msg) => {
+  log(msg, 5);
+}
+
+const logBanner = (msg) => {
+  log(msg, 6);
+}
+
+const logDebug = (msg) => {
+  if (getArgs().debug) {
+    log(msg, 7);
+  }
+}
+const logDebugTrace = (filename, method, e) => {
+  if (getArgs().debug) {
+    log(`ERROR in ${filename}`, 7);
+    log(`...method : ${method}`, 7);
+    log(`...message : ${e.message}`, 7);
+  }
+}
+const logDebugResponse = (response) => {
+  if (getArgs().debug) {
+    console.log(response);
+  }
+}
+
 const log = (msg, type) => {
-  var prefix;
+  var prefix, msgContent, currentDateTime = moment(new Date()).format("HH:mm:ss");
+
   if (type === 0 || !type) {
       prefix =  figures.play;
-      if (!isTestRunning) console.info(chalk.yellow('\n' + prefix + ' ' + msg.toUpperCase()));
+      msgContent = `\n${currentDateTime} - ${prefix} ${msg.toUpperCase()}`;
+      if (!isTestRunning) console.info(chalk.yellow(msgContent));
   }
   if (type === 1) {
-      prefix =  figures.pointer + figures.pointer + figures.pointer;
-      if (!isTestRunning) console.info(chalk.cyan(prefix + ' ' + msg));
+      prefix = figures.pointer.repeat(3);
+      msgContent = `${currentDateTime} - ${prefix} ${msg}`;
+      if (!isTestRunning) console.info(chalk.cyan(msgContent));
   }
   if (type === 2) {
-      prefix = figures.pointer + figures.pointer + figures.pointer + figures.pointer + figures.pointer + figures.pointer;
-      if (!isTestRunning) console.info(chalk.green(prefix + ' ' + msg + '\n'));
+      prefix = figures.pointer.repeat(6);
+      msgContent = `${currentDateTime} - ${prefix} ${msg}\n`;
+      if (!isTestRunning) console.info(chalk.green(msgContent));
   }
   if (type === 3) {
-      prefix = figures.pointer + figures.pointer + figures.pointer + figures.pointer + figures.pointer + figures.pointer;
-      console.info(chalk.red('\n' + prefix + ' ' + msg + '\n'));
+      prefix = figures.pointer.repeat(6);
+      msgContent = `${currentDateTime} - ${prefix} ${msg}`;
+      console.info(chalk.red(msgContent));
   }
   if (type === 4) {
-      prefix = figures.pointer + figures.pointer + figures.pointer + figures.pointer + figures.pointer + figures.pointer;
-      console.info(chalk.keyword('orange')(prefix + ' ' + msg + '\n'));
+      prefix = figures.pointer.repeat(6);
+      msgContent = `\n${currentDateTime} - ${prefix} ${msg}\n`;
+      console.info(chalk.keyword('orange')(msgContent));
   }
-}
-
-
-
-function replaceInFile(file, fromString, toString) {
-  const fromRegExp = new RegExp(fromString, 'g');
-
-  logInfo('replace in file: ' + file);
-
-  return new Promise((resolve, reject) => {
-    replace({
-      files: file,
-      from: fromRegExp,
-      to: toString,
-      disableGlobs: true,
-    }, function (err, response) {
-      if (err) {
-        return reject(err);
-      } else {
-        return resolve(response);
-      }
-    })
-  })
-}
-
-function replaceInPath(rootPath, fromString, toString) {
-  const fromRegExp = new RegExp(fromString, 'g');
-
-  return replace.sync({
-    files: [rootPath + '/**/*.*'],
-    from: fromRegExp,
-    to: toString,
-  });
-}
-
-
-function compareValues(key, order='asc') {
-  return function(a, b) {
-    if(!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) {
-        return 0;
-    }
-
-    const varA = (typeof a[key] === 'string') ?
-      a[key].toUpperCase() : a[key];
-    const varB = (typeof b[key] === 'string') ?
-      b[key].toUpperCase() : b[key];
-
-    let comparison = 0;
-    if (varA > varB) {
-      comparison = 1;
-    } else if (varA < varB) {
-      comparison = -1;
-    }
-    return (
-      (order == 'desc') ? (comparison * -1) : comparison
-    );
-  };
-}
-
-function sortArray(arr, key, order) {
-  return arr.sort(compareValues(key, order));
-}
-
-function removeArrayDuplicates(myArr, prop) {
-  return myArr.filter((obj, pos, arr) => {
-    if (prop) {
-      return arr.map(mapObj => mapObj[prop]).indexOf(obj[prop]) === pos;
-    } else {
-      return arr.map(mapObj => mapObj).indexOf(obj) === pos;
-    }
-  });
-}
-
-function getArraySum(myArr, prop) {
-  return myArr.reduce((prev, cur) => {
-    return prev + cur[prop];
-  }, 0);
-}
-
-function getArgs() {
-  const argv = require('yargs').argv;
-
-  const processArgs = process.env._CSDR_ARGS;
-
-  let args = {};
-
-  if (processArgs) {
-    processArgs.split(',').forEach((item) => {
-      const itemSplit = item.split(':');
-      args[itemSplit[0].trim()] = itemSplit[1].trim();
-    })
+  if (type === 5) {
+      prefix = figures.star.repeat(3);
+      msgContent = `${currentDateTime} - ${prefix} ${msg}\n`;
+      console.info(chalk.keyword('yellow')(msgContent));
   }
-
-  return {
-    root: argv._[0],
-    ...argv,
-    ...args
+  if (type === 6) {
+      prefix = figures.star.repeat(3)
+      msgContent = prefix + ' ' + msg + ' ' + prefix;
+      console.info('\n\n');
+      console.info(chalk.keyword('yellow')(figures.star.repeat(msgContent.length)));
+      console.info(chalk.keyword('yellow')(msgContent));
+      console.info(chalk.keyword('yellow')(figures.star.repeat(msgContent.length)));
+      console.info('\n');
+  }
+  if (type === 7) {
+    prefix = figures.pointer.repeat(10);
+    msgContent = `${currentDateTime} - ${prefix} ${msg}`;
+    console.info(chalk.keyword('yellow')(msgContent));
   }
 }
 
-function getXMLJsContent(file) {
-  const content = fs.readFileSync(file, { encoding: 'utf8' });
+function logVersion() {
+  try {
+    const nmToolsPackageJsonPath = path.join(process.cwd(), 'node_modules', '@eui', 'tools', 'package.json');
+    const jsonContent = getJsonFileContent(nmToolsPackageJsonPath);
+    const version = jsonContent.version;
+    logBanner(`eUI TOOLS version : ${version}`)
+  } catch(e) {}
+}
 
-  var output;
-  xml2js.parseString(content, function (err, result) {
-    output = result;
-  });
 
-  return output;
-}
 
-function getFolders(parentPath) {
-  if (isDirExists(parentPath)) {
-    return fs.readdirSync(parentPath).filter(f => fs.statSync(path.join(parentPath, f)).isDirectory());
-  } else {
-    return [];
-  }
-}
 
-function getFiles(parentPath) {
-  return fs.readdirSync(parentPath).filter(f => fs.statSync(path.join(parentPath, f)).isFile());
-}
 
-function logBigTitle(text) {
-  console.log('\n\n');
-  console.log(
-    chalk.yellow(
-      figlet.textSync(text, { horizontalLayout: 'full' })
-    )
-  );
-  console.log('\n');
-}
 
-function removeFilesExtension(rootPath, extension) {
-  return new Promise((resolve, reject) => {
-    glob(rootPath + "/**/*" + extension,
-      function (err, files) {
-        if (err) {
-          return reject(err);
-        } else {
-          var processed = 0;
-          files.forEach(function (file) {
-            const dir = path.dirname(file);
-            const filename = path.basename(file);
-            // logInfo('remove extention for file : ' + filename + ' in ' + dir);
-            const filenameUpdate = filename.substr(0, filename.indexOf(extension));
-            fs.renameSync(file, dir + "/" + filenameUpdate);
-            processed++;
-          });
-          logInfo(processed + " files processed");
-          resolve();
-        }
-      });
-  })
-}
 
-function splitNpmPkg(npmPkg) {
-  const scope = npmPkg.substr(0, npmPkg.indexOf('/'));
-  const name = npmPkg.substr(npmPkg.indexOf('/') + 1);
 
-  return { scope: scope, name: name };
-}
 
 
 
@@ -662,7 +765,14 @@ module.exports.logTitle = logTitle;
 module.exports.logInfo = logInfo;
 module.exports.logSuccess = logSuccess;
 module.exports.logError = logError;
+module.exports.logErrorTrace = logErrorTrace;
 module.exports.logWarning = logWarning;
+module.exports.logAccent = logAccent;
+module.exports.logBanner = logBanner;
+module.exports.logDebug = logDebug;
+module.exports.logDebugTrace = logDebugTrace;
+module.exports.logDebugResponse = logDebugResponse;
+
 module.exports.replaceInFile = replaceInFile;
 module.exports.replaceInPath = replaceInPath;
 module.exports.sortArray = sortArray;
@@ -672,6 +782,8 @@ module.exports.getArgs = getArgs;
 module.exports.getXMLJsContent = getXMLJsContent;
 module.exports.getFolders = getFolders;
 module.exports.getFiles = getFiles;
+module.exports.getFilesGlob = getFilesGlob;
 module.exports.logBigTitle = logBigTitle;
 module.exports.removeFilesExtension = removeFilesExtension;
 module.exports.splitNpmPkg = splitNpmPkg;
+module.exports.logVersion = logVersion;