@zohodesk/codestandard-validator 0.0.6-exp-18 → 0.0.6-exp-20

package/build/hooks/Precommit/lint.js

@@ -7,12 +7,13 @@ const fs = require('fs');
 const path = require('path');
 const {
   getEslintExecutablePath
-} = require('../../utils/EslintConfigFileUtils/getEslintExecutablePath');
+} = require('../../utils/ConfigFileUtils/getEslintExecutablePath');
 const {
   getNodeModulesPath
 } = require('../../utils/General/getNodeModulesPath');
 const {
-  filterFiles
+  filterFiles,
+  filterWarningInFile
 } = require('../../utils/FileAndFolderOperations/filterFiles');
 const {
   Logger
@@ -35,276 +36,176 @@ const {
   shouldWarningsAbortCommit
 } = getConfigurationPrecommit();
 
-/**
- * @function isMergeCommit - This method check whether it is merge or not
- * @returns {Boolean} -  return boolean based on latest merge changes
- */
-async function isMergeCommit() {
+/* ------------------------------------------
+   Git Helpers
+------------------------------------------ */
+
+function isMergeCommit() {
   return new Promise((resolve, reject) => {
-    exec('git rev-parse -q --verify MERGE_HEAD', (error, stderr, stdout) => {
-      if (error) {
-        reject(error.toString().trim());
-      } else if (stderr) {
-        resolve(stderr.trim());
-      } else if (stdout) {
-        resolve(stdout.trim());
-      }
+    exec('git rev-parse -q --verify MERGE_HEAD', (err, stderr, stdout) => {
+      if (err) return reject(err.toString().trim());
+      resolve((stdout || stderr).trim());
     });
   });
 }
-
-/**
- * @function {getStagedFiles} - methods return staged files
- * @returns {Array<string>} -  array of  files
- */
-
-async function getStagedFiles() {
+function getStagedFiles() {
   return new Promise((resolve, reject) => {
-    exec("git diff --staged --name-only", (error, stderr, stdout) => {
-      if (error) {
-        if (error != null) reject("Couldn't fetch staged files");
-      } else if (stderr) {
-        resolve(filterDeltedFileFromStagedFiles(stderr.trim().split('\n')));
-      } else if (stdout.trim() === '') {
-        resolve(stdout.trim());
-      }
+    exec('git diff --staged --name-only', (err, stderr, stdout) => {
+      if (err) return reject("Couldn't fetch staged files");
+      const output = stderr || stdout;
+      if (!output.trim()) return resolve([]);
+      resolve(filterDeletedFiles(output.trim().split('\n')));
     });
   });
 }
-
-/**
- * @function {filterDeltedFileFromStagedFiles} - filter deleted staged files
- * @param {Array<string>} files - staged files
- * @returns 
- */
-function filterDeltedFileFromStagedFiles(files) {
-  return files.filter(file => {
-    const absolutePath = path.resolve(getRootDirectory(), file);
-    if (fs.existsSync(absolutePath)) {
-      return true;
-    }
-    return false;
-  });
+function filterDeletedFiles(files) {
+  return files.filter(file => fs.existsSync(path.resolve(getRootDirectory(), file)));
 }
 
-/**
- * @function findEslintErrors - method  Lint given file based on given configuration
- * @param {*} file - path of file to lint
- * @returns {Array<string>} -  array of command line report as a string 
- */
+/* ------------------------------------------
+   Lint Helpers
+------------------------------------------ */
 
-async function findEslintErrors(file) {
-  let nodeModulesPathOfProject = `${getNodeModulesPath()}`;
-  let eslintExecutablePath = getEslintExecutablePath();
-  let eslintConfigurationFilePath = `${nodeModulesPathOfProject}/.eslintrc.js`;
-  let isEslintExecutablePresent = fs.existsSync(eslintExecutablePath) ? true : false;
-  let isNodeModulesPresent = fs.existsSync(nodeModulesPathOfProject);
-  if (isNodeModulesPresent) {
-    if (isEslintExecutablePresent) {
-      return new Promise((resolve, reject) => {
-        exec(`npx --ignore-existing "${eslintExecutablePath}" --config "${eslintConfigurationFilePath}" --no-inline-config --resolve-plugins-relative-to="${nodeModulesPathOfProject}/node_modules" ${file}`, (error, stderr, stdout) => {
-          if (stderr) {
-            resolve(stderr.trim().split('\n'));
-          } else if (error) {
-            Logger.log(Logger.FAILURE_TYPE, error);
-            reject("Error executing eslint command");
-          } else {
-            resolve([]);
-          }
-        });
-      });
-    } else {
-      Logger.log(Logger.INFO_TYPE, 'Eslint executable not found. make sure eslint plugin is installed');
-    }
-  } else {
-    Logger.log(Logger.INFO_TYPE, 'node_modules not found');
+function lintFiles(filePath) {
+  const ext = path.extname(filePath);
+  if (['.js', '.ts', '.tsx', '.jsx'].includes(ext)) {
+    return findEslintErrors(filePath);
+  }
+  if (['.css', '.scss'].includes(ext)) {
+    return findStyleLintErrors(filePath);
   }
+  return Promise.resolve([]);
 }
-/**
- * @function {calculateGitDiffForFile} -  method calculate diff of file
- * @param {*} branch_name - branch name
- * @param {*} file - path of file
- * @returns {Promise<Array<string>>} - array of command line report as a string 
- */
-async function calculateGitDiffForFile(branch_name, file) {
-  let gitDiffCommand = `git diff -U0 ${branch_name.trim()} ${file}`;
+function findStyleLintErrors(filePath) {
+  const config = path.resolve(getNodeModulesPath(), '.stylelintrc.js');
+  const absolutePath = path.join(getRootDirectory(), filePath);
   return new Promise((resolve, reject) => {
-    exec(gitDiffCommand, (error, stderr) => {
-      if (stderr) {
-        resolve(stderr.trim().split('\n'));
-      } else if (error) {
-        reject(error);
+    exec(`npx stylelint ${absolutePath} --config ${config}`, {
+      cwd: getNodeModulesPath()
+    }, (err, stderr) => {
+      if (stderr) return resolve(stderr.trim().split('\n'));
+      if (err) {
+        Logger.log(Logger.FAILURE_TYPE, err);
+        return reject('Error executing stylelint command');
       }
+      resolve([]);
+    });
+  }).catch(err => {
+    Logger.log(Logger.FAILURE_TYPE, 'Issue linting CSS files');
+    return [];
+  });
+}
+function findEslintErrors(filePath) {
+  const eslintPath = getEslintExecutablePath();
+  const nodeModulesPath = getNodeModulesPath();
+  const eslintConfig = `${nodeModulesPath}/.eslintrc.js`;
+  if (!fs.existsSync(eslintPath)) {
+    Logger.log(Logger.INFO_TYPE, 'Eslint executable not found. Ensure eslint plugin is installed.');
+    return Promise.resolve([]);
+  }
+  return new Promise((resolve, reject) => {
+    const cmd = `npx --ignore-existing "${eslintPath}" --config "${eslintConfig}" --no-inline-config --resolve-plugins-relative-to="${nodeModulesPath}/node_modules" ${filePath}`;
+    exec(cmd, (err, stderr) => {
+      if (stderr) return resolve(stderr.trim().split('\n'));
+      if (err) {
+        Logger.log(Logger.FAILURE_TYPE, err);
+        return reject('Error executing eslint command');
+      }
+      resolve([]);
+    });
+  });
+}
+function calculateGitDiffForFile(branch, file) {
+  return new Promise((resolve, reject) => {
+    exec(`git diff -U0 ${branch.trim()} ${file}`, (err, stderr) => {
+      if (stderr) return resolve(stderr.trim().split('\n'));
+      if (err) return reject(err);
     });
   });
 }
-/**
- * @function {areAllPluginsInstalled} -  method whether plugin is installed or not
- * @returns {Boolean} - return boolean based on plugin installed or not
- */
+
+/* ------------------------------------------
+   Utility
+------------------------------------------ */
 
 function areAllPluginsInstalled() {
-  let unInstalledPlugins = checkIfPluginsAreInstalled().uninstalledPlugins;
-  console.log("unInstalledPlugins", unInstalledPlugins);
-  return unInstalledPlugins.length === 0 ? true : false;
+  const {
+    uninstalledPlugins
+  } = checkIfPluginsAreInstalled();
+  console.log('unInstalledPlugins', uninstalledPlugins);
+  return uninstalledPlugins.length === 0;
 }
-
-/**
- * @function {isOnlyWarningsPresentInFile} - method that checks if only eslint warnings are present in a file
- * @returns {Boolean} - returns boolean based on only warnings present or not in file
- */
-function isOnlyWarningsPresentInFile(eslintErrorsPresent) {
-  let severityOfEachErrorInFile = [];
-  eslintErrorsPresent.map(error => {
-    let partsInString = error.split(" ");
-    let severityOfError = partsInString.find(word => word === 'error' || word === 'warning');
-    severityOfEachErrorInFile.push(severityOfError);
-  });
-  return !severityOfEachErrorInFile.includes('error');
+function isOnlyWarningsPresent(errors) {
+  const severities = errors.map(e => e.split(' ').find(w => w === 'error' || w === 'warning'));
+  return !severities.includes('error');
 }
 
-/**
- * @function {preCommitHook} - method execute pre commit hook
- * @returns {void}
- */
+/* ------------------------------------------
+   Main Execution
+------------------------------------------ */
 
 async function preCommitHook() {
   Logger.log(Logger.INFO_TYPE, 'Executing pre commit hook...');
-  Logger.log(Logger.INFO_TYPE, `working dir  : ${process.cwd()}`);
+  Logger.log(Logger.INFO_TYPE, `Working directory: ${process.cwd()}`);
   try {
-    let isMerge = await isMergeCommit();
-    Logger.log(Logger.INFO_TYPE, 'Looks like you have merged. So skipping pre commit check');
+    await isMergeCommit();
+    Logger.log(Logger.INFO_TYPE, 'Looks like you have merged. So skipping pre-commit check');
     process.exit(0);
-  } catch (error) {
-    if (areAllPluginsInstalled()) {
-      let staged_files = [];
-      let eslintConfigFiles = ['.eslintrc.js'];
-      let exemptionFiles = [];
-      let current_branch = '';
-      let hasEslintErrorsInChangedLines = false;
-      let hasEslintErrorsInFiles = false;
-      let areFilesStaged = false;
-      let shouldAbortCommit = false;
-      try {
-        current_branch = await getBranchName();
-      } catch {
-        Logger.log(Logger.INFO_TYPE, "Error fetching current branch");
-      }
+  } catch {
+    if (!areAllPluginsInstalled()) {
+      Logger.log(Logger.FAILURE_TYPE, 'Commit failed due to missing eslint plugins');
+      Logger.log(Logger.INFO_TYPE, `Run \x1b[37mnpx ZDPrecommit setupPlugins\x1b[33m in the project root`);
+      process.exit(1);
+    }
+    let files = await getStagedFiles();
+    if (files.length === 0) {
+      Logger.log(Logger.INFO_TYPE, 'No files staged. Stage files before committing.');
+      return;
+    }
+    const currentBranch = await getBranchName().catch(() => '');
+    const filteredFiles = filterFiles(files, ['.eslintrc.js'], true);
+    let shouldAbort = false;
+    for (const file of filteredFiles) {
+      if (!getSupportedLanguage().includes(path.extname(file))) continue;
       try {
-        staged_files = await getStagedFiles();
-        if (!staged_files.length == 0) {
-          staged_files = filterFiles(staged_files, eslintConfigFiles, true);
-
-          // staged_files = filterFiles(staged_files,exemptionFiles) //this is the code for giving exemption to a file during pre commit
-          // if(staged_files.length === 0){
-          //     Logger.log(Logger.SUCCESS_TYPE,`Commit Successful`)
-          //     process.exit(0)
-          // }
-          areFilesStaged = true;
-          for (let file in staged_files) {
-            let currentFileName = staged_files[file];
-            let changedLinesArray = [];
-            let eslintErrorsInChangedLines = [];
-            let isOnlyEslintWarningsPresentInFile = false;
-            if (getSupportedLanguage().includes(path.extname(staged_files[file]))) {
-              try {
-                var eslintErrorsInFile = await findEslintErrors(staged_files[file]);
-                // eslintErrorsInFile = impactBasedPrecommit == false ? filterWarningInFile(eslintErrorsInFile) : eslintErrorsInFile
-                if (staged_files[file] && typeof staged_files[file] == 'string') {
-                  if (!eslintErrorsInFile.length == 0) {
-                    //Calculating changed lines in a file and storing them in respective arrays
-                    if (impactBasedPrecommit) {
-                      //git diff is computed and stored in an array
-                      let git_diff = await calculateGitDiffForFile(current_branch, staged_files[file]);
-                      changedLinesArray = git_diff.filter(line => line.startsWith('@@'));
-                      let changedLinesStartArray = [];
-                      let changedLinesEndArray = [];
-                      for (let number of changedLinesArray) {
-                        let changesStartLine = parseInt(number.split(' ')[2].split(',')[0]);
-                        changedLinesStartArray.push(changesStartLine);
-                        let changesEndLine = number.split(' ')[2].split(',')[1];
-                        if (changesEndLine === undefined) {
-                          changedLinesEndArray.push(changesStartLine);
-                        } else {
-                          changedLinesEndArray.push(changesStartLine + parseInt(changesEndLine) - 1);
-                        }
-                      }
-                      for (let error = 1; error < eslintErrorsInFile.length - 2; error++) {
-                        //eslintErrorsInFile[error].trim() - 69:26  error => Do not hardcode content. Use I18N key instead  no-hardcoding/no-hardcoding, 
-                        //eslintErrorsInFile[error].trim().split(' ')[0] => 69:26
-                        //eslintErrorsInFile[error].trim().split(' ')[0].split(':')[0] => 69
-
-                        let eslintErrorLineNumber = eslintErrorsInFile[error].trim().split(' ')[0].split(':')[0];
-                        for (let lineNumber in changedLinesStartArray) {
-                          if (eslintErrorLineNumber >= changedLinesStartArray[lineNumber] && eslintErrorLineNumber <= changedLinesEndArray[lineNumber]) {
-                            eslintErrorsInChangedLines.push(eslintErrorsInFile[error]);
-                          }
-                        }
-                      }
-                      if (eslintErrorsInChangedLines.length > 0) {
-                        isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(eslintErrorsInChangedLines);
-                        Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${currentFileName}\x1b[0m`);
-                        for (let eslintError of eslintErrorsInChangedLines) {
-                          Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${eslintError.trimEnd()}\x1b[0m`);
-                        }
-                        if (shouldWarningsAbortCommit) {
-                          hasEslintErrorsInChangedLines = true;
-                          shouldAbortCommit = true;
-                        } else if (!shouldWarningsAbortCommit && isOnlyEslintWarningsPresentInFile) {
-                          hasEslintErrorsInChangedLines = false;
-                        } else if (!shouldWarningsAbortCommit && !isOnlyEslintWarningsPresentInFile) {
-                          hasEslintErrorsInChangedLines = true;
-                          shouldAbortCommit = true;
-                        }
-                      }
-                    } else {
-                      if (eslintErrorsInFile.length > 0) {
-                        let startIndex = 1;
-                        let endIndex = eslintErrorsInFile.length - 2;
-                        let listOsEslintErrors = eslintErrorsInFile.slice(startIndex, endIndex);
-                        isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(listOsEslintErrors);
-                        Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${currentFileName}\x1b[0m`);
-                        for (let eslintError of listOsEslintErrors) {
-                          Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${eslintError.trimEnd()}\x1b[0m`);
-                        }
-                        if (shouldWarningsAbortCommit) {
-                          hasEslintErrorsInFiles = true;
-                          shouldAbortCommit = true;
-                        } else if (!shouldWarningsAbortCommit && isOnlyEslintWarningsPresentInFile) {
-                          hasEslintErrorsInFiles = false;
-                        } else if (!shouldWarningsAbortCommit && !isOnlyEslintWarningsPresentInFile) {
-                          hasEslintErrorsInFiles = true;
-                          shouldAbortCommit = true;
-                        }
-                      }
-                    }
-                  }
-                }
-              } catch (err) {
-                Logger.log(Logger.FAILURE_TYPE, err);
-                Logger.log(Logger.FAILURE_TYPE, "Error in executing eslint command");
-              }
+        const lintResults = await lintFiles(file);
+        if (lintResults.length === 0) continue;
+        let relevantErrors = [];
+        if (impactBasedPrecommit) {
+          const gitDiff = await calculateGitDiffForFile(currentBranch, file);
+          const changeHunks = gitDiff.filter(line => line.startsWith('@@'));
+          const ranges = changeHunks.map(h => {
+            const start = parseInt(h.split(' ')[2].split(',')[0]);
+            const len = parseInt(h.split(' ')[2].split(',')[1]) || 1;
+            return [start, start + len - 1];
+          });
+          for (const error of lintResults.slice(1, -2)) {
+            const lineNum = parseInt(error.trim().split(' ')[0].split(':')[0]);
+            if (ranges.some(([start, end]) => lineNum >= start && lineNum <= end)) {
+              relevantErrors.push(error);
             }
           }
-        } else if (staged_files.length === 0) {
-          Logger.log(Logger.INFO_TYPE, 'No files have been staged. Stage your files before committing');
+        } else {
+          relevantErrors = lintResults.slice(1, -2);
         }
-      } catch {
-        Logger.log(Logger.INFO_TYPE, 'Error executing pre commit hook');
-      }
-      if (shouldAbortCommit) {
-        Logger.log(Logger.FAILURE_TYPE, `There are eslint errors/warnings present. So commit is aborted.`);
-        process.exit(1);
-      } else if (shouldAbortCommit === false && staged_files.length !== 0) {
-        Logger.log(Logger.SUCCESS_TYPE, `Commit Successful`);
-        process.exit(0);
+        if (relevantErrors.length) {
+          const onlyWarnings = isOnlyWarningsPresent(relevantErrors);
+          Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${file}\x1b[0m`);
+          relevantErrors.forEach(e => Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${e.trimEnd()}\x1b[0m`));
+          if (shouldWarningsAbortCommit || !onlyWarnings) {
+            shouldAbort = true;
+          }
+        }
+      } catch (err) {
+        Logger.log(Logger.FAILURE_TYPE, err);
       }
-    } else {
-      Logger.log(Logger.FAILURE_TYPE, 'Commit failed since some eslint plugins are not installed');
-      Logger.log(Logger.INFO_TYPE, `Kindly execute the command \x1b[37mnpx ZDPrecommit setupPlugins \x1b[33mfrom the location where package.json is present to install the plugins`);
-      Logger.log(Logger.INFO_TYPE, 'Execute the command and kindly try committing again.');
+    }
+    if (shouldAbort) {
+      Logger.log(Logger.FAILURE_TYPE, 'There are eslint errors/warnings. Aborting commit.');
       process.exit(1);
     }
+    Logger.log(Logger.SUCCESS_TYPE, 'Commit Successful');
+    process.exit(0);
   }
 }
 preCommitHook();

package/build/hooks/Precommit/pre-commit.js

@@ -4,14 +4,380 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = validateRemotePackages;
-var _executeSyncCommands = require("../../utils/General/executeSyncCommands");
-var _getNodeModulesPath = require("../../utils/General/getNodeModulesPath");
+// const {exec, execSync} = require('child_process')
+// const fs = require('fs')
+// const path = require('path')
+// const { getEslintExecutablePath } = require('../../utils/ConfigFileUtils/getEslintExecutablePath')
+// const { getNodeModulesPath } = require('../../utils/General/getNodeModulesPath')
+// const { filterFiles, filterWarningInFile } = require('../../utils/FileAndFolderOperations/filterFiles')
+// const { Logger } = require('../../utils/Logger/Logger')
+// const { checkIfPluginsAreInstalled } = require('../../utils/PluginsInstallation/checkIfPluginsAreInstalled')
+// const { getBranchName } = require('../../utils/GitActions/gitActions')
+// const { getConfigurationPrecommit, getSupportedLanguage  } = require('../../utils/General/getGeneralInfo')
+// const { getRootDirectory } = require('../../utils/General/RootDirectoryUtils/getRootDirectory')
+// const { impactBasedPrecommit, shouldWarningsAbortCommit } = getConfigurationPrecommit()
+
+// /**
+//  * @function isMergeCommit - This method check whether it is merge or not
+//  * @returns {Boolean} -  return boolean based on latest merge changes
+//  */
+// async function isMergeCommit() {
+//     return new Promise((resolve, reject) => {
+//         exec('git rev-parse -q --verify MERGE_HEAD', (error,stderr,stdout) => {
+//             if(error){
+//                 reject(error.toString().trim())
+//             }
+//             else if(stderr){
+//                 resolve(stderr.trim())
+//             }
+//             else if(stdout){
+//                 resolve(stdout.trim())
+//             }
+//         })
+//     })
+
+// }
+
+// /**
+//  * @function {getStagedFiles} - methods return staged files
+//  * @returns {Array<string>} -  array of  files
+//  */
+
+// async function getStagedFiles(){
+//     return new Promise((resolve, reject) => {
+//         exec("git diff --staged --name-only",(error,stderr,stdout) =>{
+//            if (error){
+//             if(error != null)
+//             reject("Couldn't fetch staged files")
+//            }
+//            else if(stderr){
+//             resolve(filterDeltedFileFromStagedFiles(stderr.trim().split('\n')))
+//            }
+//            else if(stdout.trim() === ''){
+//             resolve(stdout.trim())
+//            }
+//         })
+//     })
+
+// }
+
+// /**
+//  * @function {filterDeltedFileFromStagedFiles} - filter deleted staged files
+//  * @param {Array<string>} files - staged files
+//  * @returns 
+//  */
+// function filterDeltedFileFromStagedFiles(files){
+//     return files.filter((file) =>{
+//         const absolutePath= path.resolve(getRootDirectory(),file)
+//         if(fs.existsSync(absolutePath)){
+//             return true
+//         }
+//         return false
+//     })
+// }
+
+// async function lintFiles(filePath){
+//     switch(path.extname(filePath)){
+//         case '.js' ||'.ts' || '.tsx' || '.jsx' : {
+//             return await findEslintErrors(filePath    )
+//         }
+
+//         case '.css' || '.scss' :{
+//             return await findStyleLintErrors(filePath)
+//         }
+//         default : {
+//             return []
+//         }
+//     }
+// }
+
+// /**
+//  * @function findEslintErrors - method  Lint given file based on given configuration
+//  * @param {*} file - path of file to lint
+//  * @returns {Array<string>} -  array of command line report as a string 
+//  */
+
+//  function findEslintErrors(file){
+//     let nodeModulesPathOfProject = `${getNodeModulesPath()}`
+//     let eslintExecutablePath = getEslintExecutablePath()
+//     let eslintConfigurationFilePath = `${nodeModulesPathOfProject}/.eslintrc.js`
+//     let isEslintExecutablePresent = fs.existsSync(eslintExecutablePath) ? true : false
+//     let isNodeModulesPresent = fs.existsSync(nodeModulesPathOfProject)
+
+//     if(isNodeModulesPresent){
+//         if(isEslintExecutablePresent){
+//             return new Promise ((resolve, reject) => {
+//                 exec(`npx --ignore-existing "${eslintExecutablePath}" --config "${eslintConfigurationFilePath}" --no-inline-config --resolve-plugins-relative-to="${nodeModulesPathOfProject}/node_modules" ${file}`,(error,stderr,stdout) => {
+//                     if(stderr){
+//                         resolve(stderr.trim().split('\n'))
+//                     }
+//                     else if(error){
+//                         Logger.log(Logger.FAILURE_TYPE,error)
+//                         reject("Error executing eslint command")
+//                     }
+//                     else{
+//                         resolve([])
+//                     }
+//                 })
+//             })
+//         }
+//         else{
+//             Logger.log(Logger.INFO_TYPE,'Eslint executable not found. make sure eslint plugin is installed')
+//         }
+//     }
+//     else{
+//         Logger.log(Logger.INFO_TYPE,'node_modules not found')
+//     }
+// }
+
+// /**
+//  * 
+//  * @param {*} params 
+//  */
+//  function findStyleLintErrors(filePath) {
+//     const configFilePath = path.resolve(getNodeModulesPath(),'.stylelintrc.json')
+//     const absolutePath = path.join(getRootDirectory(),filePath)
+//     try{
+//         return new Promise ((resolve, reject) => {
+//             exec(`npx stylelint ${absolutePath} --config ${configFilePath}`,{cwd:getNodeModulesPath()},(error,stderr,stdout) => {
+//                 if(stderr){
+//                     resolve(stderr.trim().split('\n'))
+//                 }
+//                 else if(error){
+//                     Logger.log(Logger.FAILURE_TYPE,error)
+//                     reject("Error executing eslint command")
+//                 }
+//                 else{
+//                     resolve([])
+//                 }
+//             })
+//         })
+//     }catch(error){
+//         Logger.log(Logger.FAILURE_TYPE,`Issue is lint css files`)
+//         return []
+//     }
+// }
+
+// /**
+//  * @function {calculateGitDiffForFile} -  method calculate diff of file
+//  * @param {*} branch_name - branch name
+//  * @param {*} file - path of file
+//  * @returns {Promise<Array<string>>} - array of command line report as a string 
+//  */
+// async function calculateGitDiffForFile(branch_name,file){
+//     let gitDiffCommand = `git diff -U0 ${branch_name.trim()} ${file}`
+//     return new Promise ((resolve,reject) => {        
+//         exec(gitDiffCommand,(error, stderr) => {
+//             if(stderr){
+//                 resolve(stderr.trim().split('\n'))
+//             }
+//             else if(error) {
+//                 reject(error)
+//             }
+//         })
+//     })
+// }
+// /**
+//  * @function {areAllPluginsInstalled} -  method whether plugin is installed or not
+//  * @returns {Boolean} - return boolean based on plugin installed or not
+//  */
+
+// function areAllPluginsInstalled(){
+//     let unInstalledPlugins = checkIfPluginsAreInstalled().uninstalledPlugins
+//     return unInstalledPlugins.length === 0 ? true : false
+// }
+
+// /**
+//  * @function {isOnlyWarningsPresentInFile} - method that checks if only eslint warnings are present in a file
+//  * @returns {Boolean} - returns boolean based on only warnings present or not in file
+//  */
+// function isOnlyWarningsPresentInFile(eslintErrorsPresent){
+//     let severityOfEachErrorInFile = []
+//     eslintErrorsPresent.map(error => {
+//         let partsInString = error.split(" ")
+//         let severityOfError = partsInString.find(word => word === 'error' || word === 'warning'|| word === '✖')
+//         severityOfEachErrorInFile.push(severityOfError)
+//     })
+//     return  !(severityOfEachErrorInFile.includes('✖') || severityOfEachErrorInFile.includes('error'))
+// }
+
+// /**
+//  * @function {preCommitHook} - method execute pre commit hook
+//  * @returns {void}
+//  */
+
+// async function preCommitHook() {
+//     Logger.log(Logger.INFO_TYPE,'Executing pre commit hook...')
+//     Logger.log(Logger.INFO_TYPE,`working dir  : ${process.cwd()}`)
+//     try{
+//         let isMerge = await isMergeCommit();
+//         Logger.log(Logger.INFO_TYPE,'Looks like you have merged. So skipping pre commit check');
+//         process.exit(0);
+//     }
+//     catch(error){
+//         if(areAllPluginsInstalled()){
+//             let staged_files = []
+//             let eslintConfigFiles = ['.eslintrc.js']
+//             let exemptionFiles = []
+//             let current_branch = ''
+//             let hasEslintErrorsInChangedLines = false
+//             let hasEslintErrorsInFiles = false
+//             let areFilesStaged = false
+//             let shouldAbortCommit = false
+//             try{
+//                 current_branch = await getBranchName()
+//             }
+//             catch{
+//                 Logger.log(Logger.INFO_TYPE,"Error fetching current branch")
+//             }
+//             try{
+//                 staged_files = await getStagedFiles()
+
+//                 if(!staged_files.length == 0){
+//                     const {JsFiles:staged_filesJS, CssFiles} = filterFiles(staged_files,eslintConfigFiles,true)
+
+//                     // staged_filesJS = filterFiles(staged_filesJS,exemptionFiles) //this is the code for giving exemption to a file during pre commit
+//                     // if(staged_filesJS.length === 0){
+//                     //     Logger.log(Logger.SUCCESS_TYPE,`Commit Successful`)
+//                     //     process.exit(0)
+//                     // }
+//                     areFilesStaged = true
+//                     var stagedFiles = [...staged_filesJS,...CssFiles]
+//                     for (let file in stagedFiles){
+//                         let currentFileName = stagedFiles[file]
+//                         let changedLinesArray = []
+//                         let eslintErrorsInChangedLines = []
+//                         let isOnlyEslintWarningsPresentInFile = false
+
+//                         if(getSupportedLanguage().includes(path.extname(stagedFiles[file]) )){
+//                             try{
+//                                 var errorsInFile= await lintFiles(stagedFiles[file])
+//                                 // eslintErrorsInFile = impactBasedPrecommit == false ? filterWarningInFile(errorsInFile) : errorsInFile
+//                                 if(stagedFiles[file] && typeof(stagedFiles[file]) == 'string'){
+//                                     if(! errorsInFile.length == 0){
+//                                         //Calculating changed lines in a file and storing them in respective arrays
+//                                         if(impactBasedPrecommit) {
+
+//                                             //git diff is computed and stored in an array
+//                                             let git_diff = await calculateGitDiffForFile(current_branch,stagedFiles[file])
+//                                             changedLinesArray = git_diff.filter((line) => line.startsWith('@@'))
+
+//                                             let changedLinesStartArray = []
+//                                             let changedLinesEndArray = []
+
+//                                             for (let number of changedLinesArray){
+//                                                 let changesStartLine = parseInt(number.split(' ')[2].split(',')[0])
+//                                                 changedLinesStartArray.push(changesStartLine)
+//                                                 let changesEndLine = number.split(' ')[2].split(',')[1]
+//                                                 if(changesEndLine === undefined){
+//                                                     changedLinesEndArray.push(changesStartLine)
+//                                                 }
+//                                                 else{
+//                                                     changedLinesEndArray.push(changesStartLine + parseInt(changesEndLine) - 1)
+//                                                 }
+//                                             }
+//                                             for (let error=1; error < errorsInFile.length - 2; error++){
+//                                                 //errorsInFile[error].trim() - 69:26  error => Do not hardcode content. Use I18N key instead  no-hardcoding/no-hardcoding, 
+//                                                 //errorsInFile[error].trim().split(' ')[0] => 69:26
+//                                                 //errorsInFile[error].trim().split(' ')[0].split(':')[0] => 69
+
+//                                                 let eslintErrorLineNumber = errorsInFile[error].trim().split(' ')[0].split(':')[0]
+
+//                                                 for(let lineNumber in changedLinesStartArray){
+//                                                     if(eslintErrorLineNumber >= changedLinesStartArray[lineNumber] && 
+//                                                         eslintErrorLineNumber <= changedLinesEndArray[lineNumber]){
+//                                                             eslintErrorsInChangedLines.push(errorsInFile[error])
+//                                                         }
+//                                                 }
+//                                             }
+//                                             if(eslintErrorsInChangedLines.length > 0){
+//                                                 isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(eslintErrorsInChangedLines)
+//                                                 Logger.log(Logger.FAILURE_TYPE,`\x1b[1m${currentFileName}\x1b[0m`)
+//                                                 for(let eslintError of eslintErrorsInChangedLines){
+//                                                     Logger.log(Logger.FAILURE_TYPE,`\x1b[37m${eslintError.trimEnd()}\x1b[0m`)
+//                                                 }
+//                                                 if(shouldWarningsAbortCommit){
+//                                                     hasEslintErrorsInChangedLines = true
+//                                                     shouldAbortCommit = true
+//                                                 }
+//                                                 else if(!shouldWarningsAbortCommit && isOnlyEslintWarningsPresentInFile){
+//                                                     hasEslintErrorsInChangedLines = false
+//                                                 }
+//                                                 else if(!shouldWarningsAbortCommit && !isOnlyEslintWarningsPresentInFile){
+//                                                     hasEslintErrorsInChangedLines = true
+//                                                     shouldAbortCommit = true
+//                                                 }
+//                                             }  
+//                                         }else{
+//                                             if(errorsInFile.length > 0 ){
+//                                                 let startIndex = 1
+//                                                 let endIndex = errorsInFile.length - 2
+//                                                 let listOsEslintErrors = errorsInFile.slice(startIndex,endIndex)
+//                                                 isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(listOsEslintErrors)
+//                                                 Logger.log(Logger.FAILURE_TYPE,`\x1b[1m${currentFileName}\x1b[0m`)
+//                                                 for(let eslintError of listOsEslintErrors){
+//                                                     Logger.log(Logger.FAILURE_TYPE,`\x1b[37m${eslintError.trimEnd()}\x1b[0m`)
+//                                                 }
+//                                                 if(shouldWarningsAbortCommit){
+//                                                     hasEslintErrorsInFiles = true
+//                                                     shouldAbortCommit = true
+//                                                 }
+//                                                 else if(!shouldWarningsAbortCommit && isOnlyEslintWarningsPresentInFile){
+//                                                     hasEslintErrorsInFiles = false
+//                                                 }
+//                                                 else if(!shouldWarningsAbortCommit && !isOnlyEslintWarningsPresentInFile){
+//                                                     hasEslintErrorsInFiles = true
+//                                                     shouldAbortCommit = true
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 } 
+//                             }
+//                             catch(err){
+//                                 Logger.log(Logger.FAILURE_TYPE,err)
+//                                 Logger.log(Logger.FAILURE_TYPE,"Error in executing eslint command")
+//                             }
+
+//                         }
+//                     }
+//                 }
+//                 else if(staged_files.length === 0){
+//                     Logger.log(Logger.INFO_TYPE,'No files have been staged. Stage your files before committing')
+//                 }
+//             }
+//             catch{
+//                 Logger.log(Logger.INFO_TYPE,'Error executing pre commit hook')
+//             }
+//             if(shouldAbortCommit){
+//                 Logger.log(Logger.FAILURE_TYPE, `There are eslint errors/warnings present. So commit is aborted.`);
+//                 process.exit(1);
+//             }
+//             else if(shouldAbortCommit === false && staged_files.length !== 0){
+//                 Logger.log(Logger.SUCCESS_TYPE, `Commit Successful`);
+//                 process.exit(0);
+//             }
+//         }
+//         else{
+//             Logger.log(Logger.FAILURE_TYPE,'Commit failed since some eslint plugins are not installed')
+//             Logger.log(Logger.INFO_TYPE,`Kindly execute the command \x1b[37mnpx ZDPrecommit setupPlugins \x1b[33mfrom the location where package.json is present to install the plugins`)
+//             Logger.log(Logger.INFO_TYPE,'Execute the command and kindly try committing again.')
+//             process.exit(1)
+//         }
+//     }
+// }
+
+// preCommitHook()
+
+const {
+  getNodeModulesPath
+} = require("../../utils/General/getNodeModulesPath");
 const {
   cloneViaCdt
 } = require("../../utils/CloneCommonLinterRepo/cloneViaCdt");
 const {
-  createEslintConfigFile
-} = require("../../utils/EslintConfigFileUtils/createEslintConfigFile");
+  createConfigFiles
+} = require("../../utils/ConfigFileUtils/createConfigFiles");
 const {
   getLastCommitHash,
   getStoredCommitHash
@@ -26,17 +392,18 @@ async function validateRemotePackages() {
   try {
     if (!(getStoredCommitHash() == getLastCommitHash())) {
       await executeMethodsThatReturnBooleanValue("Make sure zgit.csez.zohocorpin.com is accessible", cloneViaCdt, null);
-      await executeMethodsThatReturnBooleanValue("Some issue occurred in creating eslint config file.", createEslintConfigFile, null);
+      await executeMethodsThatReturnBooleanValue("Some issue occurred in creating eslint config file.", createConfigFiles, null);
       Logger.log(Logger.SUCCESS_TYPE, "Pre commit setup successfull");
     }
     execSync("npx ZDPrecommit setupPlugins", {
-      cwd: (0, _getNodeModulesPath.getNodeModulesPath)()
+      cwd: getNodeModulesPath()
     });
   } catch (error) {
     Logger.log(Logger.FAILURE_TYPE, `Kindly retry npm install. & ${error.message}`);
   }
 }
-(async function () {
+async function lint() {
   await validateRemotePackages();
-  require('./lint');
-})();
+  require("./lint");
+}
+lint();

package/build/lib/postinstall.js

@@ -7,8 +7,8 @@ const {
   setupHusky
 } = require("../utils/HuskySetup/setupHusky");
 const {
-  createEslintConfigFile
-} = require("../utils/EslintConfigFileUtils/createEslintConfigFile");
+  createConfigFiles
+} = require("../utils/ConfigFileUtils/createConfigFiles");
 const {
   Logger
 } = require("../utils/Logger/Logger");
@@ -34,7 +34,7 @@ async function postInstall() {
     await executeMethodsThatReturnBooleanValue("Some issue in writing node_modules path to json", writeFsPaths, null);
     isGitInitialized() ? await executeMethodsThatReturnBooleanValue("Some issue occurred in setting up husky.", setupHusky, null) : null;
     await executeMethodsThatReturnBooleanValue("Make sure zgit.csez.zohocorpin.com is accessible", cloneViaCdt, null);
-    await executeMethodsThatReturnBooleanValue("Some issue occurred in creating eslint config file.", createEslintConfigFile, null);
+    await executeMethodsThatReturnBooleanValue("Some issue occurred in creating eslint config file.", createConfigFiles, null);
     Logger.log(Logger.SUCCESS_TYPE, "Pre commit setup successfull");
     // arePluginsInstalled();
   } catch (error) {

package/build/utils/CloneCommonLinterRepo/cloneViaCdt.js

@@ -49,7 +49,7 @@ function cloneViaCdt() {
   const runningEnv = getRunningEnv();
   if (runningEnv === "CI" || runningEnv === "DEVAUTOMATION") {
     Logger.log(Logger.INFO_TYPE, `Running in ${runningEnv}`);
-    absoluteEndPoint = `https://${userName}:${decrypt(token, 12)}@${endPoint}`;
+    absoluteEndPoint = `https://${userName}:${decrypt(token, process.env.DECRYPT_TOKEN)}@${endPoint}`;
   }
   var commandToCloneCommonConfigRepo = `npx cdt clone --clone:type=${type} --clone:url=${absoluteEndPoint} --clone:branch=${branch} --clone:cacheDir=${cacheDirectory} --clone:proj:name=${commonLinterRepoName}`;
   let isCommonConfigurationClonedSuccessfully = executeSynchronizedCommands(execSync, [commandToCloneCommonConfigRepo, {

package/build/utils/ConfigFileUtils/createConfigFiles.js

@@ -0,0 +1,68 @@
+"use strict";
+
+const path = require('path');
+const {
+  writeFileSync,
+  existsSync,
+  unlinkSync,
+  readFileSync
+} = require('fs');
+const {
+  getNodeModulesPath
+} = require('../General/getNodeModulesPath.js');
+const {
+  Logger
+} = require('../Logger/Logger.js');
+const {
+  executeSynchronizedCommands
+} = require('../General/executeSyncCommands.js');
+const {
+  getServicePathElseCommon
+} = require('./getLintConfiguration.js');
+
+/**
+ * Creates the ESLint configuration file from the service-specific or common template.
+ * Also creates the Stylelint configuration file if available.
+ *
+ * @returns {boolean} Success status of ESLint config creation
+ */
+function createConfigFiles() {
+  const eslintConfigFilePath = path.join(getNodeModulesPath(), '.eslintrc.js');
+  const stylelintConfigFilePath = path.join(getNodeModulesPath(), '.stylelintrc.js');
+  const {
+    pathOfServiceSpecificEslintConfigFile,
+    cssLintConfig
+  } = getServicePathElseCommon();
+  try {
+    const eslintContent = readConfig(pathOfServiceSpecificEslintConfigFile, 'eslint');
+    const stylelintContent = readConfig(cssLintConfig, 'stylelint');
+    if (stylelintContent) {
+      writeConfig(stylelintConfigFilePath, stylelintContent, 'stylelint');
+    }
+    if (existsSync(eslintConfigFilePath)) {
+      executeSynchronizedCommands(unlinkSync, [eslintConfigFilePath], 'ESLint configuration file removed successfully!', 'Unable to remove the ESLint config file.', false, false);
+    }
+    return writeConfig(eslintConfigFilePath, eslintContent, 'eslint');
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, error);
+    Logger.log(Logger.FAILURE_TYPE, 'Error occurred while creating ESLint config file');
+    return false;
+  }
+}
+
+/**
+ * Reads a configuration file with logging and error handling.
+ */
+function readConfig(filePath, type) {
+  return executeSynchronizedCommands(readFileSync, [filePath, 'utf-8'], '', `Unable to read content of ${type} config file.`, true, false);
+}
+
+/**
+ * Writes a configuration file with logging and error handling.
+ */
+function writeConfig(filePath, content, type) {
+  return executeSynchronizedCommands(writeFileSync, [filePath, content, 'utf-8'], `${type[0].toUpperCase() + type.slice(1)} configuration file created successfully!`, `Unable to create and write a ${type} configuration file.`, false, true);
+}
+module.exports = {
+  createConfigFiles
+};

package/build/utils/ConfigFileUtils/getEslintExecutablePath.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const path = require('path');
+const {
+  readdirSync
+} = require('fs');
+const {
+  getNodeModulesPath
+} = require('../General/getNodeModulesPath');
+const {
+  executeSynchronizedCommands
+} = require('../General/executeSyncCommands');
+const {
+  getLibraryInstalledLocation
+} = require('../General/getLibraryInstalledLocation');
+function getEslintExecutablePath() {
+  let eslintLibraryName = 'eslint';
+  let librariesInNodeModulesOfProject = executeSynchronizedCommands(readdirSync, [path.join(getNodeModulesPath(), 'node_modules')], '', 'Unable to get the plugins inside node_modules', true, false);
+  let isEslintInstalledinProject = librariesInNodeModulesOfProject.some(library => library === eslintLibraryName);
+  return isEslintInstalledinProject ? path.join(getNodeModulesPath(), 'node_modules', eslintLibraryName, 'bin', 'eslint.js') : path.join(getLibraryInstalledLocation(), 'node_modules', eslintLibraryName, 'bin', 'eslint.js');
+}
+module.exports = {
+  getEslintExecutablePath
+};

package/build/utils/ConfigFileUtils/getLintConfiguration.js

@@ -0,0 +1,54 @@
+"use strict";
+
+const path = require('path');
+const {
+  existsSync
+} = require('fs');
+const {
+  endPoint,
+  commonLinterRepoName
+} = require("../../../jsonUtils/commonLinterRepoDetails.js");
+const {
+  getRepoName
+} = require('../GitActions/gitActions.js');
+const {
+  getLibraryInstalledLocation
+} = require('../General/getLibraryInstalledLocation.js');
+const {
+  executeMethodsThatMayThrowException
+} = require("../General/wrapperFunctionToExecuteAFunction.js");
+
+/**
+ * @function getLintConfiguration - returns eslint configuration file from common linters repo
+ * @returns {object} - containing properties of the eslint configuration file
+ */
+function getServicePathElseCommon() {
+  const repoName = getRepoName();
+  const libraryInstalledLocation = getLibraryInstalledLocation();
+  let commonConfigPath = path.join(libraryInstalledLocation, commonLinterRepoName, 'common', 'index.js');
+  const _configurationPath = repoName && existsSync(path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, 'index.js')) ? path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, 'index.js') : commonConfigPath;
+  let _pathOfServiceSpecificEslintConfigFile = repoName && existsSync(path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, '.eslintrc.js')) ? path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, '.eslintrc.js') : path.join(libraryInstalledLocation, commonLinterRepoName, 'common', '.eslintrc.js');
+  let _pluginVersionPath = repoName && existsSync(path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, 'pluginVersion.js')) ? path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, 'pluginVersion.js') : undefined;
+  let _stylelintPath = repoName && existsSync(path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, '.stylelintrc.js')) ? path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, '.stylelintrc.js') : path.join(libraryInstalledLocation, commonLinterRepoName, 'common', '.stylelintrc.js');
+  return {
+    configurationPath: _configurationPath,
+    pathOfServiceSpecificEslintConfigFile: _pathOfServiceSpecificEslintConfigFile,
+    pluginVersionPath: _pluginVersionPath,
+    cssLintConfig: _stylelintPath
+  };
+}
+function getLintConfigurationUtil() {
+  const {
+    configurationPath
+  } = getServicePathElseCommon();
+  const exceptionHandleObject = {
+    rulesConfig: [{}, {}],
+    plugins: [],
+    extendPlugins: []
+  };
+  return executeMethodsThatMayThrowException(exceptionHandleObject, `Kindly Ensure that Configuration is setup in Configuration repo \n ${endPoint}`, require, configurationPath);
+}
+module.exports = {
+  getLintConfigurationUtil,
+  getServicePathElseCommon
+};

package/build/utils/FileAndFolderOperations/filterFiles.js

@@ -3,7 +3,9 @@
 const {
   Logger
 } = require('../Logger/Logger');
-
+const {
+  existsSync
+} = require("fs");
 /**
  * @function filterFiles - removes certain files from set of source files
  * @param {Array} arrayOfFilesToBeFiltered - array of files which must be filtered 
@@ -12,6 +14,29 @@ const {
  * @returns {Array} - containing the resultant set of files after filtering
  */
 function filterFiles(arrayOfFilesToBeFiltered, filesToBeRemoved, isConfigFileNeedToBeRemoved = false) {
+  /**
+   * @function filterFilesByExtension - filter javascript files. omit feature files
+   * @param {Array<String>} lintFiles - linter files as Array
+   * @returns {Array<String>} 
+   * */
+  function filterFilesByExtension(lintFiles) {
+    return lintFiles.reduce((files, currentFile) => {
+      if (currentFile.includes('.feature') && existsSync(currentFile)) {
+        files.featureFiles.push(currentFile);
+      }
+      if (currentFile.includes('.js') || currentFile.includes('.ts') || currentFile.includes('.tsx') || currentFile.includes('.jsx') && existsSync(currentFile)) {
+        files.JsFiles.push(currentFile);
+      }
+      if (currentFile.includes('.css') || currentFile.includes('.scss') && existsSync(currentFile)) {
+        files.CssFiles.push(currentFile);
+      }
+      return files;
+    }, {
+      featureFiles: [],
+      JsFiles: [],
+      CssFiles: []
+    });
+  }
   if (filesToBeRemoved.length !== 0) {
     if (isConfigFileNeedToBeRemoved) {
       arrayOfFilesToBeFiltered.filter(file => {
@@ -31,7 +56,7 @@ function filterFiles(arrayOfFilesToBeFiltered, filesToBeRemoved, isConfigFileNee
         return false;
       }
     });
-    return filteredArrayofFilesWithoutConfigFile;
+    return filterFilesByExtension(filteredArrayofFilesWithoutConfigFile);
   } else if (filesToBeRemoved.length === 0) {
     return arrayOfFilesToBeFiltered;
   }

package/build/utils/General/getGeneralInfo.js

@@ -18,6 +18,7 @@ const {
  * @function getTimeStampInfo - to fetch various timestamp details
  * @returns {object} - each property of the object denotes various timestamp details
  */
+
 function getTimeStampInfo() {
   const date = new Date();
   return {
@@ -34,6 +35,7 @@ function getTimeStampInfo() {
  * @function getEnv - to fetch the os type
  * @returns {string} - indicates the os
  */
+
 function getEnv() {
   return os.type();
 }
@@ -42,6 +44,7 @@ function getEnv() {
  * @function getConfigPath - get a path of lint configuration path
  * @returns {string}
  */
+
 function getConfigPath() {
   const configPath = path.resolve(process.cwd(), 'lint.config.js');
   const defaultConfigPath = path.resolve(__dirname, '..', '..', 'setup', 'sample.config.js');
@@ -52,27 +55,29 @@ function getConfigPath() {
  * @function getConfiguration - get configuration object of lint configuration
  * @returns
  */
+
 function getConfigurationPrecommit() {
   return require(getConfigPath());
 }
 
 /**
- * @function getSupportedLanguage - get support language
- * @returns {Array<string>}
+ * @function getRunningEnv - Retrieves the current running environment by executing the `npm config get lint_env` command.
+ * @returns {string} The current lint environment value set in the npm config.
  */
+
 function getSupportedLanguage() {
   const {
     supportedExtensions
   } = getConfigurationPrecommit();
   const _language = supportedExtensions;
+  _language.push('.js');
+  _language.push('.jsx');
+  _language.push('.ts');
+  _language.push('.tsx');
+  _language.push('.css');
+  _language.push('.scss');
   return _language;
 }
-
-/**
- * @function getRunningEnv - Retrieves the current running environment by executing the `npm config get lint_env` command.
- * @returns {string} The current lint environment value set in the npm config.
- */
-
 function getRunningEnv() {
   const command = "npm config get lint_env";
   return execSync(command, {
@@ -91,7 +96,7 @@ function getRunningEnv() {
 function getLastCommitHash() {
   try {
     const cmd = `curl --header "PRIVATE-TOKEN: ${readOnlyToken}" --url ${commitHashEndPoint}`;
-    return JSON.parse(execSync(cmd))[0]["id"];
+    return JSON.parse(execSync(cmd))[0].id;
   } catch (err) {
     Logger.log(Logger.FAILURE_TYPE, err);
     return null;

package/build/utils/PluginsInstallation/Worker/installPluginsByWoker.js

@@ -3,15 +3,18 @@
 const {
   Worker
 } = require('worker_threads');
+const {
+  Logger
+} = require('../../Logger/Logger');
 async function installPluginsByWorker(plugins) {
   try {
     const results = await Promise.all(plugins.map(pkg => runWorker({
       packageName: pkg.packageName,
       version: pkg.version
     })));
-    console.log('Package are installed By from workers:', results.join('\n'));
+    Logger.log(Logger.SUCCESS_TYPE, 'Package are installed By from workers:', results.join('\n'));
   } catch (error) {
-    console.error('Error:', error);
+    Logger.log(Logger.FAILURE_TYPE, 'Error:', error);
   }
 }
 function runWorker(data) {

package/build/utils/PluginsInstallation/checkIfPluginsAreInstalled.js

@@ -19,7 +19,7 @@ const {
 } = require('../General/wrapperFunctionToExecuteAFunction');
 const {
   getServicePathElseCommon
-} = require('../EslintConfigFileUtils/getLintConfiguration');
+} = require('../ConfigFileUtils/getLintConfiguration');
 function getAllPlugins() {
   let serviceSpecificPlugins = [];
   const pathToCommonPluginsFile = path.join(getLibraryInstalledLocation(), commonLinterRepoName, 'common', 'pluginVersion.js');
@@ -58,7 +58,10 @@ function checkIfPluginsAreInstalled() {
     if (isPluginPresent && checkPluginHasProperVersion(packageName, pluginPath, version)) {
       return false;
     }
-    return `${packageName}@${version}`;
+    return {
+      packageName,
+      version
+    };
   }).filter(Boolean);
   if (uninstalledPlugins.length > 0) {
     plugin.noPluginMessage = '';

package/build/utils/PluginsInstallation/installPlugins.js

@@ -23,6 +23,7 @@ const {
  * @function installPlugins - installs uninstalled plugins for the project
  * @returns {boolean} - indicating if plugins to be installed are installed successfully or not
  */
+
 function installPlugins(pluginsToBeInstalled) {
   if (pluginsToBeInstalled.length === 0) {
     Logger.log(Logger.INFO_TYPE, 'Plugins are already installed');

package/index.js

@@ -1,4 +1,4 @@
-const { getLintConfigurationUtil } = require("./build/utils/EslintConfigFileUtils/getLintConfiguration");
+const { getLintConfigurationUtil } = require("./build/utils/ConfigFileUtils/getLintConfiguration");
 const { rulesConfig, plugins, extendPlugins } = getLintConfigurationUtil();
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/codestandard-validator",
-  "version": "0.0.6-exp-18",
+  "version": "0.0.6-exp-20",
   "description": "library to enforce code standard using eslint",
   "main": "index.js",
   "scripts": {
@@ -22,6 +22,7 @@
     "@babel/core": "7.24.7",
     "@babel/plugin-transform-runtime": "7.24.7",
     "@babel/preset-env": "7.24.7",
-    "husky": "7.0.4"
+    "husky": "7.0.4",
+    "stylelint": "^16.0.0"
   }
 }