@zeesoft/i18n-verify 1.0.0

package/dist/lib/i18n.js

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 _dGraphic = _interopRequireDefault(require("../utils/2dGraphic.js"));
+var _logs = _interopRequireDefault(require("../utils/logs.js"));
+var _fs = _interopRequireDefault(require("fs"));
+var _file = require("../utils/file.js");
+var _index = _interopRequireDefault(require("./validator/index.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class I18nVerify {
+  #driver;
+
+  /**
+   * @param {BaseDriver} driver
+   */
+  constructor(driver) {
+    this.#driver = driver;
+  }
+
+  /**
+   * @param {string} verificationArea - xpath selector of verification area
+   * @param {string} staticLocators - user parsed xpath selectors to find text of elements under verification area
+   * @param {string} description - identity of verification area ex: page, popup, form etc name
+   */
+
+  async verify({
+    verificationArea,
+    staticLocators,
+    description
+  }) {
+    let locArray = [];
+    let xPath;
+    const options = _config.default.getOptions();
+    if (Array.isArray(staticLocators) && staticLocators.length > 0) {
+      for (const locator of staticLocators) {
+        let updatedLocator = verificationArea + locator;
+        locArray.push(updatedLocator);
+      }
+    } else {
+      xPath = verificationArea !== '' ? verificationArea + _constants.COMMON_XPATH : _constants.COMMON_XPATH;
+    }
+    _config.default.incrementCounter();
+    const img_name = `${_config.default.getSSCount().toString().padStart(3, '0')}_${description.replace(/[^\w\s]/gi, '').replace(/\s+/g, '')}.png`;
+    const reviewed_image = (0, _file.joinPaths)(_reports.default.reviewedReports(), img_name);
+    await this.#captureCurrentScreen(reviewed_image);
+    if (options?.i18nVerify) {
+      try {
+        if (locArray.length > 0) {
+          for (const locator of locArray) {
+            await this.#getElement(verificationArea, locator, img_name, description);
+          }
+        } else {
+          await this.#getElements(verificationArea, xPath, img_name, description);
+        }
+      } catch (elementsError) {
+        _logs.default.error('Elements not found under specified locator on page: ', description);
+      }
+    } else {
+      _logs.default.info('Skipped i18n verification as per user configuration...');
+    }
+  }
+  async #getElement(verificationArea, locator, img_name, desc) {
+    const ele = await this.#driver.getElement(locator);
+    if (ele && (await this.#driver.isElementDisplayed(ele))) {
+      let str;
+      try {
+        str = await this.#driver.getElementString(ele);
+        try {
+          await this.#generateReports(verificationArea, ele, img_name, str, desc);
+        } catch (reportError) {
+          console.error('Error generating report of element:', reportError);
+        }
+      } catch (textError) {
+        console.error('Error getting text of element:', textError);
+      }
+    } else {
+      console.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)) {
+          let uiStrings;
+          try {
+            uiStrings = await this.#driver.getElementStrings(el);
+            try {
+              for (const str of uiStrings) {
+                await this.#generateReports(verificationArea, el, img_name, str, desc);
+              }
+            } catch (reportError) {
+              console.error('Error generating report of element:', reportError);
+            }
+          } catch (textError) {
+            console.error('Error getting text of elements:', textError);
+          }
+        }
+      }
+    } else {
+      console.error('No elements found:', xpaths);
+    }
+  }
+  async #generateReports(verificationArea, el, image_name, str, desc) {
+    //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);
+    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]);
+          }
+        }
+      });
+      await this.#highlightReports(verificationArea, el, color, src_img, dest_img, str);
+    }
+  }
+  async #highlightReports(verificationArea, el, color, src_img, rep_img, str) {
+    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)) {
+        await this.#captureCurrentScreen(src_img);
+        _fs.default.copyFileSync(src_img, rep_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);
+    const areaColor = _constants.COLOR.GRB_BLUE;
+    const areaRec = await this.#getRect(area);
+    const eleRec = await this.#getRect(el);
+    await _dGraphic.default.drawRectangle(areaRec, areaColor, rep_img);
+    await _dGraphic.default.drawRectangle(eleRec, color, rep_img);
+  }
+  async #captureCurrentScreen(imagePath) {
+    await this.#driver.captureScreenshot(imagePath);
+  }
+  async #getRect(el) {
+    const elObj = await this.#driver.getElementDimension(el);
+    return {
+      x: elObj[0],
+      y: elObj[1],
+      height: elObj[2],
+      width: elObj[3]
+    };
+  }
+  #defineColor(i18nStatus, str) {
+    _reports.default.incrementCount(i18nStatus);
+    _logs.default.debug(`[${str}] ${_constants.STATUS_COLOR[i18nStatus][1]} ${_constants.STATUS_INFO[i18nStatus]}${'\x1b[0m'}`);
+    return _constants.STATUS_COLOR[i18nStatus][0];
+  }
+}
+exports.default = I18nVerify;

package/dist/lib/validator/base.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _config = _interopRequireDefault(require("../config.js"));
+var _globalize = _interopRequireDefault(require("globalize"));
+var _cldrData = _interopRequireDefault(require("cldr-data"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const parserType = {
+  dateParser:
+  /**
+   * @type {Globalize.dateParser}
+   */
+  () => {},
+  numberParser:
+  /**
+   * @type {Globalize.numberParser}
+   */
+  () => {}
+};
+class BaseValidator {
+  #config = {};
+  #type;
+  constructor(type) {
+    this.#type = type;
+    this.#addBaseConfig();
+    this.buildConfig();
+    this.#buildParser();
+  }
+  #addBaseConfig() {
+    this.addToConfig('supportedLocales', _config.default.getOptions()?.supportedLocales, []);
+    this.addToConfig('defaultLocale', _config.default.getDefaultLocale());
+    this.addToConfig('defaultLanguage', _config.default.getDefaultLocale()?.split(/[-_ ]/g)[0]);
+    this.addToConfig('language', _config.default.getLocale()?.split(/[-_ ]/g)[0]);
+    this.addToConfig('locale', _config.default.getLocale());
+    this.addToConfig('qaLocale', _config.default.getQALocale());
+  }
+  buildConfig() {
+    throw new Error(`{{${this.#type}}} buildConfig should be implemented by child class`);
+  }
+  #buildParser() {
+    _globalize.default.load(_cldrData.default.entireSupplemental());
+    _globalize.default.load(_cldrData.default.entireMainFor(this.#getCompatibleLocale(this.#config.defaultLocale), this.#getCompatibleLocale(this.#config.locale)));
+  }
+  #getCompatibleLocale(locale) {
+    if (this.isQaLocale()) {
+      return 'en';
+    }
+    locale = locale.replace(/[-_ ]/g, '-');
+    const locales = _cldrData.default.availableLocales;
+    let suitableLocale;
+    if (locales.find(l => l === locale)) {
+      suitableLocale = locale;
+    } else {
+      const temp = locale.split('-')[0];
+      if (locales.find(l => l === temp)) {
+        suitableLocale = temp;
+      } else {
+        suitableLocale = locale;
+      }
+    }
+    return suitableLocale;
+  }
+
+  /**
+   * to check if the given text is a valid issue type
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  validate(string) {
+    throw new Error(`{{${this.#type}}} validate should be implemented by child class`);
+  }
+
+  /**
+   * check whether the given value is a valid type of the supplied locale
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  isInternationalized(string) {
+    throw new Error(`{{${this.#type}}} isInternationalized should be implemented by child class`);
+  }
+  setConfig(data) {
+    this.#config = data;
+  }
+  addToConfig(prop, value, defaultValue) {
+    this.#config[prop] = value ?? defaultValue;
+  }
+  getConfig() {
+    return this.#config;
+  }
+  isSupportedLocale() {
+    return this.#config.supportedLocales.includes(this.currentLocale());
+  }
+  isQaLocale() {
+    return this.currentLocale() === this.#config?.qaLocale;
+  }
+  isDefaultLocale() {
+    return this.currentLocale() === this.defaultLocale();
+  }
+  defaultLocale() {
+    return this.#config?.defaultLocale;
+  }
+  defaultLanguage() {
+    return this.#config?.defaultLanguage;
+  }
+  currentLocale() {
+    return this.#config?.locale;
+  }
+  currentLanguage() {
+    return this.#config.language;
+  }
+
+  /**
+   *
+   * @param {String} locale
+   * @returns {Globalize}
+   */
+  getGlobalize(locale) {
+    return (0, _globalize.default)(this.#getCompatibleLocale(locale));
+  }
+}
+exports.default = BaseValidator;

package/dist/lib/validator/currency.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _regex = require("../../utils/regex.js");
+var _base = _interopRequireDefault(require("./base.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class CurrencyValidator extends _base.default {
+  constructor() {
+    super('currency');
+  }
+
+  /**
+   *
+   * @override
+   */
+  validate(string) {
+    return this.#isDefaultCurrency(string) || this.isInternationalized(string);
+  }
+
+  /**
+   *
+   * @override
+   */
+  isInternationalized(string) {
+    return this.#isValidCurrency(this.currentLocale(), string);
+  }
+
+  /**
+   *
+   * @override
+   */
+  buildConfig() {}
+
+  /**
+   * check whether the given value is a valid percentage of the supplied locale
+   *
+   * @param {String} locale
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  #isValidCurrency(locale, string) {
+    const currencyCode = this.#getCurrencyCode(locale);
+    const currencySymbol = this.#getCurrencySymbol(locale, currencyCode);
+    const hasCurrencySymbolOrCode = this.#hasCurrencyCodeOrSymbol(currencyCode, currencySymbol, string);
+    if (!hasCurrencySymbolOrCode) {
+      return false;
+    }
+
+    // strip currency code and symbol and then validate number
+    const clearNumber = this.#clearNumber(currencyCode, currencySymbol, string);
+    return !isNaN(this.getGlobalize(locale).numberParser()(clearNumber));
+  }
+  #hasCurrencyCodeOrSymbol(code, symbol, string) {
+    return new RegExp(`^(?:-)?(?:${code}|\\${symbol})(?:${(0, _regex.getSpacePattern)()})?(?:-)?[0-9,. ]+$`, 'gi').test(string) || new RegExp(`^(?:[- ]?)[0-9,. ]+(?:${(0, _regex.getSpacePattern)()})?(?:${code}|\\${symbol})$`, 'gi').test(string);
+  }
+  #clearNumber(code, symbol, string) {
+    return string.replace(new RegExp(`^(?:-)(?:${(0, _regex.getSpacePattern)()})?`, 'gi'), '').replace(new RegExp(`^(?:${(0, _regex.getSpacePattern)()})?(?:${code}|\\${symbol})`, 'gi'), '').replace(new RegExp(`^(?:-)(?:${(0, _regex.getSpacePattern)()})?`, 'gi'), '').replace(new RegExp(`(?:${(0, _regex.getSpacePattern)()})?(?:${code}|\\${symbol})$`, 'gi'), '').trim();
+  }
+  #getTerritory(locale) {
+    const maxLocale = this.getGlobalize(locale).cldr.supplemental(['likelySubtags', locale]) || locale;
+    return maxLocale.split(/[-_ ]/).pop();
+  }
+  #getCurrencyCode(locale) {
+    const territory = this.#getTerritory(locale);
+    const currencyData = this.getGlobalize(locale).cldr.supplemental('currencyData');
+    const currencies = currencyData.region[territory];
+    if (currencies) {
+      const currency = currencies.find(currency => {
+        const values = Object.values(currency)[0];
+        return !values._tender && (!values._to || new Date(values._to) >= new Date());
+      });
+      return currency ? Object.keys(currency)[0] : 'USD';
+    }
+    return 'USD';
+  }
+  #getCurrencySymbol(locale, currencyCode) {
+    const currencyData = this.getGlobalize(locale).cldr.main(`numbers/currencies/${currencyCode}`);
+    return currencyData?.symbol || '$';
+  }
+
+  /**
+   * check whether the given value is a valid currency of default locale
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  #isDefaultCurrency(string) {
+    return this.#isValidCurrency(this.defaultLocale(), string);
+  }
+}
+exports.default = CurrencyValidator;

package/dist/lib/validator/date.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _luxon = require("luxon");
+var _base = _interopRequireDefault(require("./base.js"));
+var _chronoNode = require("../../utils/dateUtils/chronoNode.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class DateValidator extends _base.default {
+  constructor() {
+    super('date');
+  }
+
+  /**
+   *
+   * @override
+   */
+  validate(string) {
+    return this.#isDefaultDate(string) || this.isInternationalized(string);
+  }
+
+  /**
+   *
+   * @override
+   */
+  isInternationalized(string) {
+    return this.#isValidDate(this.isQaLocale() ? this.defaultLocale() : this.currentLocale(), string);
+  }
+
+  /**
+   *
+   * @override
+   */
+  buildConfig() {}
+  #isValidDate(locale, string) {
+    return this.#verifyUsingGlobalize(locale, string) || this.#verifyUsingLuxon(locale, string) || this.#verifyUsingChrono(locale, string);
+  }
+  #isDefaultDate(string) {
+    return this.#isValidDate(this.defaultLocale(), string);
+  }
+  #verifyUsingGlobalize(locale, string) {
+    const formats = ['short', 'medium', 'long', 'full'];
+    for (let format of formats) {
+      // Try parsing as date
+      const dateParser = this.getGlobalize(locale).dateParser({
+        date: format
+      });
+      if (dateParser(string)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  #verifyUsingLuxon(locale, string) {
+    const formats = [_luxon.DateTime.DATE_SHORT, _luxon.DateTime.DATE_MED, _luxon.DateTime.DATE_FULL, _luxon.DateTime.DATE_HUGE, _luxon.DateTime.DATE_MED_WITH_WEEKDAY];
+    for (let format of formats) {
+      const parsed = _luxon.DateTime.fromFormat(string, format, {
+        locale
+      });
+      if (parsed.isValid) {
+        return true;
+      }
+    }
+    return false;
+  }
+  #verifyUsingChrono(locale, string) {
+    return (0, _chronoNode.isValid)(this.isQaLocale() ? this.defaultLocale() : locale, string);
+  }
+}
+exports.default = DateValidator;

package/dist/lib/validator/datetime.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _luxon = require("luxon");
+var _base = _interopRequireDefault(require("./base.js"));
+var _chronoNode = require("../../utils/dateUtils/chronoNode.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class DateTimeValidator extends _base.default {
+  constructor() {
+    super('dateTime');
+  }
+
+  /**
+   *
+   * @override
+   */
+  validate(string) {
+    return this.#isDefaultDateTime(string) || this.isInternationalized(string);
+  }
+
+  /**
+   *
+   * @override
+   */
+  isInternationalized(string) {
+    return this.#isValidDateTime(this.isQaLocale() ? this.defaultLocale() : this.currentLocale(), string);
+  }
+
+  /**
+   *
+   * @override
+   */
+  buildConfig() {}
+  #isValidDateTime(locale, string) {
+    return this.#verifyUsingGlobalize(locale, string) || this.#verifyUsingLuxon(locale, string) || this.#verifyUsingChrono(locale, string);
+  }
+  #isDefaultDateTime(string) {
+    return this.#isValidDateTime(this.defaultLocale(), string);
+  }
+  #verifyUsingGlobalize(locale, string) {
+    const formats = ['short', 'medium', 'long', 'full'];
+    for (let format of formats) {
+      // Try parsing as time
+      const timeParser = this.getGlobalize(locale).dateParser({
+        datetime: format
+      });
+      if (timeParser(string)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  #verifyUsingLuxon(locale, string) {
+    const formats = [_luxon.DateTime.DATETIME_SHORT, _luxon.DateTime.DATETIME_SHORT_WITH_SECONDS, _luxon.DateTime.DATETIME_MED, _luxon.DateTime.DATETIME_MED_WITH_SECONDS, _luxon.DateTime.DATETIME_MED_WITH_WEEKDAY, _luxon.DateTime.DATETIME_FULL, _luxon.DateTime.DATETIME_FULL_WITH_SECONDS, _luxon.DateTime.DATETIME_HUGE, _luxon.DateTime.DATETIME_HUGE_WITH_SECONDS];
+    for (let format of formats) {
+      const parsed = _luxon.DateTime.fromFormat(string, format, {
+        locale
+      });
+      if (parsed.isValid) {
+        return true;
+      }
+    }
+    return false;
+  }
+  #verifyUsingChrono(locale, string) {
+    return (0, _chronoNode.isValid)(this.isQaLocale() ? this.defaultLocale() : locale, string);
+  }
+}
+exports.default = DateTimeValidator;

package/dist/lib/validator/index.js

@@ -0,0 +1,156 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _constants = require("../../utils/constants.js");
+var _config = _interopRequireDefault(require("../config.js"));
+var _currency = _interopRequireDefault(require("./currency.js"));
+var _date = _interopRequireDefault(require("./date.js"));
+var _datetime = _interopRequireDefault(require("./datetime.js"));
+var _number = _interopRequireDefault(require("./number.js"));
+var _percentage = _interopRequireDefault(require("./percentage.js"));
+var _string = _interopRequireDefault(require("./string.js"));
+var _time = _interopRequireDefault(require("./time.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Validator {
+  static #issuesMap = {};
+  /**
+   * Collection of methods to validate and determine string issues
+   * @type {StringValidator}
+   */
+  static #string;
+
+  /**
+   * Collection of methods to validate and determine number issues
+   * @type {NumberValidator}
+   */
+  static #number;
+
+  /**
+   * Collection of methods to validate and determine date issues
+   * @type {DateValidator}
+   */
+  static #date;
+
+  /**
+   * Collection of methods to validate and determine date issues
+   * @type {TimeValidator}
+   */
+  static #time;
+
+  /**
+   * Collection of methods to validate and determine dateTime issues
+   * @type {DateTimeValidator}
+   */
+  static #dateTime;
+
+  /**
+   * Collection of methods to validate and determine currency issues
+   * @type {CurrencyValidator}
+   */
+  static #currency;
+
+  /**
+   * Collection of methods to validate and determine percentage issues
+   * @type {PercentageValidator}
+   */
+  static #percentage;
+  static load() {
+    Validator.#string = new _string.default();
+    Validator.#number = new _number.default();
+    Validator.#date = new _date.default();
+    Validator.#time = new _time.default();
+    Validator.#dateTime = new _datetime.default();
+    Validator.#currency = new _currency.default();
+    Validator.#percentage = new _percentage.default();
+  }
+  /**
+   *
+   * @param {String} string
+   * @returns {Promise<String>} issue type
+   */
+  static getIssueType(string) {
+    const locale = _config.default.getLocale();
+    if (locale) {
+      let type = _constants.I18N_STATUS.UNTRANSLATED;
+      if (!Validator.#issuesMap[locale]) {
+        Validator.#issuesMap[locale] = {};
+      }
+
+      // return from cache
+      if (Validator.#issuesMap[locale][string]) {
+        return Validator.#issuesMap[locale][string];
+      }
+
+      // handle DNT, Auto Ignored, Ignored and Encoding cases
+      if (this.#string.isAutoIgnoredText(string)) {
+        type = _constants.I18N_STATUS.AUTO_IGNORE;
+      } else if (this.#string.isDntText(string)) {
+        type = _constants.I18N_STATUS.DNT;
+      } else if (this.#string.isIgnoredText(string)) {
+        type = _constants.I18N_STATUS.IGNORE;
+      } else if (this.#string.hasEncodingIssue(string)) {
+        type = _constants.I18N_STATUS.ENCODING_ISSUE;
+      }
+      // handle currency cases
+      else if (this.#currency.validate(string)) {
+        type = this.#currency.isInternationalized(string) ? _constants.I18N_STATUS.CURRENCY_LOCALIZED : _constants.I18N_STATUS.CURRENCY_NOT_LOCALIZED;
+      }
+      // handle percentage cases
+      else if (this.#percentage.validate(string)) {
+        type = this.#percentage.isInternationalized(string) ? _constants.I18N_STATUS.PERCENTAGE_LOCALIZED : _constants.I18N_STATUS.PERCENTAGE_NOT_LOCALIZED;
+      }
+      //handle number cases
+      else if (this.#number.validate(string)) {
+        type = this.#number.isInternationalized(string) ? _constants.I18N_STATUS.NUMBER_LOCALIZED : _constants.I18N_STATUS.NUMBER_NOT_LOCALIZED;
+      }
+      // handle date cases
+      else if (this.#date.validate(string)) {
+        type = this.#date.isInternationalized(string) ? _constants.I18N_STATUS.DATE_LOCALIZED : _constants.I18N_STATUS.DATE_NOT_LOCALIZED;
+      }
+      // handle time cases
+      else if (this.#time.validate(string)) {
+        type = this.#time.isInternationalized(string) ? _constants.I18N_STATUS.TIME_LOCALIZED : _constants.I18N_STATUS.TIME_NOT_LOCALIZED;
+      }
+      // handle dateTime cases
+      else if (this.#dateTime.validate(string)) {
+        type = this.#dateTime.isInternationalized(string) ? _constants.I18N_STATUS.DATE_TIME_LOCALIZED : _constants.I18N_STATUS.DATE_TIME_NOT_LOCALIZED;
+      }
+      // handle string cases
+      else if (this.#string.validate(string)) {
+        // handle QA strings
+        if (this.#string.isQaLocale()) {
+          if (this.#string.isFullQaLanguageText(string)) {
+            type = _constants.I18N_STATUS.STRING_LOCALIZED;
+          } else if (this.#string.isPartialQaLanguageText(string)) {
+            type = _constants.I18N_STATUS.STRING_PARTIALLY_LOCALIZED;
+          } else {
+            type = _constants.I18N_STATUS.STRING_NOT_LOCALIZED;
+          }
+        }
+        // handle string i18n cases
+        else if (!this.#string.isDefaultLocale() && this.#string.isSupportedLocale()) {
+          if (this.#string.isLocalized(string)) {
+            type = _constants.I18N_STATUS.STRING_LOCALIZED;
+          } else if (this.#string.isPartiallyLocalizedText(string)) {
+            type = _constants.I18N_STATUS.STRING_PARTIALLY_LOCALIZED;
+          } else if (!this.#string.isInternationalized(string)) {
+            type = _constants.I18N_STATUS.STRING_NOT_LOCALIZED;
+          } else {
+            type = _constants.I18N_STATUS.UNTRANSLATED;
+          }
+        }
+      } else if (this.#string.isDefaultLocale()) {
+        type = _constants.I18N_STATUS.AUTO_IGNORE;
+      }
+
+      // add to cache
+      Validator.#issuesMap[locale][string] = type;
+      return type;
+    }
+    return _constants.I18N_STATUS.UNTRANSLATED;
+  }
+}
+exports.default = Validator;