@zeesoft/i18n-verify 2.0.2 → 2.1.3

package/dist/driver/adapters/cypress.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _cypress = require("../../utils/cypress.js");
 var _baseDriver = _interopRequireDefault(require("../baseDriver.js"));
+var _logs = _interopRequireDefault(require("../../utils/logs.js"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class CypressDriver extends _baseDriver.default {
   /**
@@ -141,7 +142,7 @@ class CypressDriver extends _baseDriver.default {
         }
       });
     } catch (textError) {
-      console.error('Error getting text of element:', textError);
+      _logs.default.error('Error getting text of element:', textError);
     }
     return elementStrings;
   }

package/dist/driver/adapters/nightwatch.js

@@ -5,7 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _baseDriver = _interopRequireDefault(require("../baseDriver.js"));
+var _logs = _interopRequireDefault(require("../../utils/logs.js"));
+var _chromeRemoteInterface = _interopRequireDefault(require("chrome-remote-interface"));
+var _fs = _interopRequireDefault(require("fs"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Default import to access CDP
+
 class NightWatchDriver extends _baseDriver.default {
   constructor(driver) {
     super(driver);
@@ -40,14 +45,20 @@ class NightWatchDriver extends _baseDriver.default {
   async getValue(element) {
     return await element.getAttribute('value');
   }
+  async getElementID(element) {
+    return await element.getAttribute('id');
+  }
   async getElementDimension(element) {
     const eleSize = await element.getRect();
     if (![null, '', undefined].includes(eleSize)) {
       return [eleSize.x, eleSize.y, eleSize.height, eleSize.width];
     }
   }
-  isElementDisplayed(element) {
-    return this.$driver.isVisible(element);
+  async isElementDisplayed(element) {
+    return await this.$driver.isVisible(element);
+  }
+  async isElementPresent(element) {
+    return await this.$driver.isPresent(element);
   }
   async getElementStrings(element) {
     const elementStrings = [];
@@ -86,10 +97,64 @@ class NightWatchDriver extends _baseDriver.default {
     return eleStr;
   }
   async captureScreenshot(file) {
-    await this.$driver.saveScreenshot(file);
+    await captureFullPage(this.$driver, file);
   }
   async getElementsCount(elements) {
     return elements.length;
   }
+  async switchIframe(frameValue) {
+    await this.$driver.frame(frameValue, () => {
+      _logs.default.debug(`Switching to ${frameValue} frame`);
+    });
+  }
+  async switchToParentframe() {
+    await this.$driver.frame(null);
+  }
+  pause(time) {
+    this.$driver.pause(time * 1000);
+  }
+  async onScreenStringHighlight(el, color) {
+    await this.$driver.execute((el, color) => {
+      el.style.border = `3px solid ${color}`;
+      setTimeout(() => {
+        el.style.border = 'none';
+      }, 50);
+    }, [el, color]);
+  }
+  async checkIfIframeIsPresent() {
+    return new Promise(res => {
+      this.$driver.isPresent({
+        selector: '//iframe',
+        locateStrategy: 'xpath',
+        suppressNotFoundErrors: true
+      }, result => {
+        res(result.value);
+      });
+    });
+  }
+  async checkIfIframeBodyIsEmpty() {
+    const bodyContent = await this.$driver.executeScript('return document.body.innerHTML');
+    return (await bodyContent.trim()) === '' ? true : false;
+  }
 }
-exports.default = NightWatchDriver;
+exports.default = NightWatchDriver;
+const captureFullPage = async ($driver, filePath) => {
+  const client = await (0, _chromeRemoteInterface.default)({
+    host: 'localhost',
+    port: 9222
+  });
+  const {
+    Page
+  } = client;
+  await Page.enable();
+  const {
+    data
+  } = await Page.captureScreenshot({
+    format: 'png',
+    captureBeyondViewport: true
+  });
+  const screenshotBuffer = Buffer.from(data, 'base64');
+  _fs.default.writeFileSync(filePath, screenshotBuffer);
+  console.log(`Screenshot saved as: ${filePath}`);
+  await client.close();
+};

package/dist/driver/adapters/selenium.js

@@ -83,10 +83,6 @@ class SeleniumDriver extends _baseDriver.default {
     });
     return elementStrings;
   }
-  async captureScreenshot(file) {
-    const screenshot = await this.driver.takeScreenshot();
-    _fs.default.writeFileSync(file, screenshot, 'base64');
-  }
   async getElementsCount(elements) {
     return elements.length;
   }

package/dist/driver/baseDriver.js

@@ -47,9 +47,15 @@ class BaseDriver {
   getElementDimension() {
     throw new Error('implementation is missing');
   }
+  getElementID() {
+    throw new Error('implementation is missing');
+  }
   isElementDisplayed() {
     throw new Error('implementation is missing');
   }
+  isElementPresent() {
+    throw new Error('implementation is missing');
+  }
   getElementString() {
     throw new Error('implementation is missing');
   }
@@ -62,6 +68,24 @@ class BaseDriver {
   getElementsCount() {
     throw new Error('implementation is missing');
   }
+  switchIframe() {
+    throw new Error('implementation is missing');
+  }
+  switchToParentframe() {
+    throw new Error('implementation is missing');
+  }
+  pause() {
+    throw new Error('implementation is missing');
+  }
+  onScreenStringHighlight() {
+    throw new Error('implementation is missing');
+  }
+  checkIfIframeIsPresent() {
+    throw new Error('implementation is missing');
+  }
+  checkIfIframeBodyIsEmpty() {
+    throw new Error('implementation is missing');
+  }
   printOnConsole(str) {
     console.log(str);
   }

package/dist/index.js

@@ -3,13 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.verify = exports.systems = exports.setLocale = exports.getReportCounts = exports.getLocale = exports.config = void 0;
+exports.verify = exports.systems = exports.setLocale = exports.logger = exports.getLocale = exports.genReportTable = exports.config = void 0;
 var _i18n = _interopRequireDefault(require("./lib/i18n.js"));
 var _constants = require("./utils/constants.js");
 var _config = _interopRequireDefault(require("./lib/config.js"));
 var _runtime = require("./utils/runtime.js");
-var _reportsTable = _interopRequireDefault(require("./utils/reportsTable.js"));
+var _reports = _interopRequireDefault(require("./lib/reports.js"));
+var _logs = _interopRequireDefault(require("./utils/logs.js"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/// <reference path="../types/index.d.ts" />
+
+const logger = exports.logger = _logs.default;
 const config = (driver, locale) => {
   _config.default.set(driver, locale);
   (0, _runtime.loadDependencies)();
@@ -19,10 +23,11 @@ const setLocale = locale => {
   _config.default.setLocale(locale);
 };
 exports.setLocale = setLocale;
-const getReportCounts = () => {
-  _reportsTable.default.generateTable();
+const genReportTable = () => {
+  _reports.default.generateAsciiTable();
+  _reports.default.generateHtml();
 };
-exports.getReportCounts = getReportCounts;
+exports.genReportTable = genReportTable;
 const getLocale = () => {
   return _config.default.getLocale();
 };

package/dist/lib/i18n.js

@@ -7,7 +7,7 @@ exports.default = void 0;
 var _baseDriver = _interopRequireDefault(require("../driver/baseDriver.js"));
 var _constants = require("../utils/constants.js");
 var _config = _interopRequireDefault(require("./config.js"));
-var _reports = _interopRequireDefault(require("../utils/reports.js"));
+var _reports = _interopRequireDefault(require("./reports.js"));
 var _graphic = _interopRequireDefault(require("../utils/graphic.js"));
 var _logs = _interopRequireDefault(require("../utils/logs.js"));
 var _fs = _interopRequireDefault(require("fs"));
@@ -68,93 +68,135 @@ class I18nVerify {
   }
   async #getElement(verificationArea, locator, img_name, desc) {
     const ele = await this.#driver.getElement(locator);
-    if (ele && (await this.#driver.isElementDisplayed(ele))) {
+    if (ele && (await this.#driver.isElementPresent(ele))) {
       let str;
       try {
         str = await this.#driver.getElementString(ele);
         try {
-          await this.#generateReports(verificationArea, ele, img_name, str, desc);
+          await this.#generateReports({
+            verificationArea,
+            ele,
+            img_name,
+            str,
+            desc
+          });
         } catch (reportError) {
-          console.error('Error generating report of element:', reportError);
+          _logs.default.error('Error generating report of element:', reportError);
         }
       } catch (textError) {
-        console.error('Error getting text of element:', textError);
+        _logs.default.error('Error getting text of element:', textError);
       }
     } else {
-      console.error('No element found:', locator);
+      _logs.default.error('No element found:', locator);
     }
   }
   async #getElements(verificationArea, xpaths, img_name, desc) {
     const eles = await this.#driver.getElements(xpaths);
     if (eles.length > 0) {
       for (const el of eles) {
-        if (await this.#driver.isElementDisplayed(el)) {
+        if (await this.#driver.isElementPresent(el)) {
           let uiStrings;
           try {
             uiStrings = await this.#driver.getElementStrings(el);
             try {
               for (const str of uiStrings) {
-                await this.#generateReports(verificationArea, el, img_name, str, desc);
+                await this.#generateReports({
+                  verificationArea,
+                  el,
+                  img_name,
+                  str,
+                  desc
+                });
               }
             } catch (reportError) {
-              console.error('Error generating report of element:', reportError);
+              _logs.default.error('Error generating report of element:', reportError);
             }
           } catch (textError) {
-            console.error('Error getting text of elements:', textError);
+            _logs.default.error('Error getting text of elements:', textError);
           }
         }
       }
-    } else {
-      console.error('No elements found:', xpaths);
+    }
+    if (await this.#driver.checkIfIframeIsPresent()) {
+      const iframes = await this.#driver.getElements('//iframe');
+      _logs.default.debug(`Total ${iframes.length} iframes are located on the ${desc}`);
+      await this.#verifyIframeElements({
+        iframes,
+        img_name,
+        desc
+      });
     }
   }
-  async #generateReports(verificationArea, el, image_name, str, desc) {
+  async #generateReports({
+    verificationArea,
+    el,
+    img_name,
+    str,
+    desc,
+    iframePresent = false
+  }) {
     //TODO: in some cases, the str is having 0
     //needs more inspection
     if (typeof str !== 'string' || !str || Number(str) === 0) {
       return;
     }
-    _reports.default.incrementCount(_constants.I18N_STATUS.REVIEWED);
     const i18nStatus = _index.default.getIssueType(str),
-      src_img = (0, _file.joinPaths)(_reports.default.reviewedReports(str, image_name), image_name);
+      src_img = (0, _file.joinPaths)(_reports.default.reviewedReports(str, img_name), img_name);
+    _reports.default.incrementCount(_constants.I18N_STATUS.REVIEWED, str, src_img, desc);
     if (i18nStatus && src_img && typeof _reports.default[i18nStatus] === 'function') {
       const color = this.#defineColor(i18nStatus, str),
-        dest_img = (0, _file.joinPaths)(_reports.default[i18nStatus](str, image_name), image_name);
-      const eles = [];
-      eles.push(el);
-      browser.perform(async function () {
-        for (const el of eles) {
-          if (true) {
-            // Highlight the element using custom JavaScript
-            browser.execute(function (el, color) {
-              el.style.border = `3px solid ${color}`;
-              setTimeout(function () {
-                el.style.border = 'none'; // Remove border
-              }, 50);
-            }, [el, color]);
-          }
-        }
+        dest_img = (0, _file.joinPaths)(_reports.default[i18nStatus](str, img_name), img_name);
+      _reports.default.incrementCount(i18nStatus, str, dest_img, desc);
+      this.#driver.onScreenStringHighlight(el, color);
+      await this.#highlightReports({
+        verificationArea,
+        el,
+        color,
+        src_img,
+        dest_img,
+        str,
+        iframePresent,
+        desc
       });
-      await this.#highlightReports(verificationArea, el, color, src_img, dest_img, str);
     }
   }
-  async #highlightReports(verificationArea, el, color, src_img, rep_img, str) {
+  async #highlightReports({
+    verificationArea,
+    el,
+    color,
+    src_img,
+    dest_img,
+    str,
+    iframePresent,
+    desc
+  }) {
     try {
-      if (_fs.default.existsSync(src_img) && !_fs.default.existsSync(rep_img)) {
-        _fs.default.copyFileSync(src_img, rep_img);
-      } else if (!_fs.default.existsSync(rep_img) && !_fs.default.existsSync(src_img)) {
+      if (_fs.default.existsSync(src_img) && !_fs.default.existsSync(dest_img)) {
+        _fs.default.copyFileSync(src_img, dest_img);
+      } else if (!_fs.default.existsSync(dest_img) && !_fs.default.existsSync(src_img)) {
         await this.#captureCurrentScreen(src_img);
-        _fs.default.copyFileSync(src_img, rep_img);
+        _fs.default.copyFileSync(src_img, dest_img);
       }
     } catch (error) {
       _logs.default.error(`zee-error#2 - ${src_img} is not exists and unable to capture screenshot`);
     }
-    const area = await this.#driver.getElement(verificationArea);
+    let areaRec;
+    let eleRec = await this.#getRect(el);
     const areaColor = _constants.COLOR.GRB_BLUE;
-    const areaRec = await this.#getRect(area);
-    const eleRec = await this.#getRect(el);
-    await _graphic.default.drawRectangle(areaRec, areaColor, rep_img);
-    await _graphic.default.drawRectangle(eleRec, color, rep_img);
+    if (iframePresent) {
+      areaRec = verificationArea;
+      const keysToUpdate = ['x', 'y'];
+      for (const key of keysToUpdate) {
+        if (key in eleRec && key in areaRec) {
+          eleRec[key] = areaRec[key] + eleRec[key];
+        }
+      }
+    } else {
+      const area = await this.#driver.getElement(verificationArea);
+      areaRec = await this.#getRect(area);
+    }
+    await _graphic.default.drawRectangle(areaRec, areaColor, dest_img);
+    await _graphic.default.drawRectangle(eleRec, color, dest_img);
   }
   async #captureCurrentScreen(imagePath) {
     await this.#driver.captureScreenshot(imagePath);
@@ -169,9 +211,49 @@ class I18nVerify {
     };
   }
   #defineColor(i18nStatus, str) {
-    _reports.default.incrementCount(i18nStatus);
-    _logs.default.debug(`[${str}] ${_constants.STATUS_COLOR[i18nStatus][1]} ${_constants.STATUS_INFO[i18nStatus]}${'\x1b[0m'}`);
+    _logs.default.debug(`${str}${_constants.STATUS_COLOR[i18nStatus][1]} ${_constants.STATUS_INFO[i18nStatus]}${'\x1b[0m'}`);
     return _constants.STATUS_COLOR[i18nStatus][0];
   }
+  async #verifyIframeElements({
+    iframes,
+    img_name,
+    desc
+  }) {
+    for (const iframe of iframes) {
+      const frameID = await this.#driver.getElementID(iframe);
+      if (frameID && frameID !== '') {
+        const verificationArea = await this.#getRect(iframe);
+        this.#driver.switchIframe(frameID);
+        this.#driver.pause(2);
+        const iframeBody = await this.#driver.getElement('//body');
+        await this.#driver.isElementPresent(iframeBody);
+        if (!(await this.#driver.checkIfIframeBodyIsEmpty())) {
+          const iframeElements = await this.#driver.getElements('//*[normalize-space(text())]');
+          if (iframeElements.length > 0) {
+            for (const el of iframeElements) {
+              if (await this.#driver.isElementPresent(el)) {
+                let uiStrings = await this.#driver.getElementStrings(el);
+                try {
+                  for (const str of uiStrings) {
+                    await this.#generateReports({
+                      verificationArea,
+                      el,
+                      img_name,
+                      str,
+                      desc,
+                      iframePresent: true
+                    });
+                  }
+                } catch (reportError) {
+                  _logs.default.error('Error generating report of iframe elements:', reportError);
+                }
+              }
+            }
+          }
+        }
+      }
+      await this.#driver.switchToParentframe();
+    }
+  }
 }
 exports.default = I18nVerify;

package/dist/{utils → lib}/reports.js

@@ -5,82 +5,93 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _path = _interopRequireDefault(require("path"));
-var _config = _interopRequireDefault(require("../lib/config.js"));
-var _file = require("./file.js");
+var _config = _interopRequireDefault(require("./config.js"));
+var _file = require("../utils/file.js");
 var _constants = require("../utils/constants.js");
+var _index = _interopRequireDefault(require("../utils/reportFactory/index.js"));
+var _cacheData = _interopRequireDefault(require("../utils/objects/cacheData.js"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class Reports {
   static #baseReportPath;
+  static #reportTimeStamp;
   static setup() {
+    Reports.#reportTimeStamp = Reports.#dateTime();
     const rootFolder = _path.default.resolve();
-    Reports.#baseReportPath = (0, _file.joinPaths)(rootFolder, _config.default.getL10nReportsPath(), Reports.#dateTime());
+    Reports.#baseReportPath = (0, _file.joinPaths)(rootFolder, _config.default.getL10nReportsPath(), Reports.#reportTimeStamp);
+  }
+  static getReportTimeStamp() {
+    return Reports.#reportTimeStamp;
+  }
+  static getReportPath() {
+    return Reports.#baseReportPath;
   }
   static reviewedReports(str = null, imgName = null) {
-    return Reports.#generateFullReportPath('reviewed', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.REVIEWED, str, imgName);
   }
   static [_constants.I18N_STATUS.STRING_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('string_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.STRING_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.STRING_NOT_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('string_not_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.STRING_NOT_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.STRING_PARTIALLY_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('string_partially_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.STRING_PARTIALLY_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.DNT](str, imgName) {
-    return Reports.#generateFullReportPath('dnt', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.DNT, str, imgName);
   }
   static [_constants.I18N_STATUS.IGNORE](str, imgName) {
-    return Reports.#generateFullReportPath('ignored', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.IGNORE, str, imgName);
   }
   static [_constants.I18N_STATUS.AUTO_IGNORE](str, imgName) {
-    return Reports.#generateFullReportPath('auto_ignored', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.AUTO_IGNORE, str, imgName);
   }
   static [_constants.I18N_STATUS.UNTRANSLATED](str, imgName) {
-    return Reports.#generateFullReportPath('un_translated', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.UNTRANSLATED, str, imgName);
   }
   static [_constants.I18N_STATUS.ENCODING_ISSUE](str, imgName) {
-    return Reports.#generateFullReportPath('encoding_issue', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.ENCODING_ISSUE, str, imgName);
   }
   static [_constants.I18N_STATUS.DATE_TIME_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('date_time_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.DATE_TIME_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.DATE_TIME_NOT_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('date_time_not_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.DATE_TIME_NOT_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.DATE_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('date_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.DATE_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.DATE_NOT_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('date_not_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.DATE_NOT_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.TIME_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('time_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.TIME_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.TIME_NOT_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('time_not_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.TIME_NOT_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.CURRENCY_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('currency_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.CURRENCY_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.CURRENCY_NOT_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('currency_not_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.CURRENCY_NOT_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.PERCENTAGE_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('percentage_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.PERCENTAGE_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.PERCENTAGE_NOT_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('percentage_not_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.PERCENTAGE_NOT_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.NUMBER_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('number_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.NUMBER_LOCALIZED, str, imgName);
   }
   static [_constants.I18N_STATUS.NUMBER_NOT_LOCALIZED](str, imgName) {
-    return Reports.#generateFullReportPath('number_not_localized', str, imgName);
+    return Reports.#generateFullReportPath(_constants.I18N_STATUS.NUMBER_NOT_LOCALIZED, str, imgName);
   }
-  static incrementCount(propertyName) {
-    if (_constants.REPORT_COUNTS.hasOwnProperty(propertyName)) {
-      _constants.REPORT_COUNTS[propertyName]++;
+  static incrementCount(type, str, imgPath, desc) {
+    if (_constants.REPORT_COUNTS.hasOwnProperty(type)) {
+      _constants.REPORT_COUNTS[type]++;
+      _cacheData.default.addString(str, type, desc, imgPath.replace(Reports.#baseReportPath, ''));
     }
   }
   static #dateTime() {
@@ -94,7 +105,7 @@ class Reports {
     return timeStamp;
   }
   static #generateFullReportPath = (type, str, imgName) => {
-    const _screenshotPath = (0, _file.joinPaths)(Reports.#baseReportPath, _config.default.getLocale(), 'screenshots', type);
+    const _screenshotPath = (0, _file.joinPaths)(Reports.#baseReportPath, _config.default.getLocale(), 'screenshots', String(type).toLowerCase());
     (0, _file.ensureDirectoryExists)(_screenshotPath, _constants.DEBUG_MODE);
     const _stringsPath = (0, _file.joinPaths)(Reports.#baseReportPath, _config.default.getLocale(), 'strings');
     (0, _file.ensureDirectoryExists)(_stringsPath, _constants.DEBUG_MODE);
@@ -116,5 +127,14 @@ class Reports {
     }
     return _screenshotPath;
   };
+  static #generateReport(type) {
+    _index.default.export(type, Reports.#baseReportPath);
+  }
+  static generateHtml() {
+    Reports.#generateReport(_constants.SUPPORTED_REPORT_TYPES.HTML);
+  }
+  static generateAsciiTable() {
+    Reports.#generateReport(_constants.SUPPORTED_REPORT_TYPES.ASCII_TABLE);
+  }
 }
 exports.default = Reports;

package/dist/lib/validator/string.js

@@ -112,7 +112,7 @@ class StringValidator extends _base.default {
    */
   isFullQaLanguageText(string) {
     const config = this.getConfig();
-    return string.slice(0, 2) === config?.mockChars?.prefix && string.slice(-2) === config?.mockChars.suffix;
+    return (string.slice(0, 2) === config?.mockChars?.prefix || string.slice(0, 2) === config?.mockChars?.prefix.toUpperCase()) && string.slice(-2) === config?.mockChars.suffix;
   }
 
   /**
@@ -123,7 +123,7 @@ class StringValidator extends _base.default {
    */
   isPartialQaLanguageText(string) {
     const config = this.getConfig();
-    return string.slice(0, 2) === config?.mockChars.prefix || string.slice(-2) === config?.mockChars.suffix;
+    return string.slice(0, 2) === config?.mockChars.prefix || string.slice(0, 2) === config?.mockChars.prefix.toUpperCase() || string.slice(-2) === config?.mockChars.suffix;
   }
 
   /**