@zeesoft/i18n-verify 1.0.0

package/dist/lib/validator/number.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _base = _interopRequireDefault(require("./base.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class NumberValidator extends _base.default {
+  constructor() {
+    super('number');
+  }
+
+  /**
+   *
+   * @override
+   */
+  validate(string) {
+    return this.#isDefaultNumber(string) || this.isInternationalized(string);
+  }
+
+  /**
+   *
+   * @override
+   */
+  isInternationalized(string) {
+    return this.#isValidNumber(this.currentLocale(), string);
+  }
+
+  /**
+   *
+   * @override
+   */
+  buildConfig() {}
+
+  /**
+   * check whether the given value is a valid number of the supplied locale
+   *
+   * @param {String} locale
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  #isValidNumber(locale, string) {
+    const parser = this.getGlobalize(locale).numberParser();
+    return !isNaN(parser(string));
+  }
+
+  /**
+   * check whether the given value is a valid number of default locale
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  #isDefaultNumber(string) {
+    return this.#isValidNumber(this.defaultLocale(), string);
+  }
+}
+exports.default = NumberValidator;

package/dist/lib/validator/percentage.js

@@ -0,0 +1,78 @@
+"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 PercentageValidator extends _base.default {
+  constructor() {
+    super('percentage');
+  }
+
+  /**
+   *
+   * @override
+   */
+  validate(string) {
+    return this.#isDefaultPercentage(string) || this.isInternationalized(string);
+  }
+
+  /**
+   *
+   * @override
+   */
+  isInternationalized(string) {
+    return this.#isValidPercentage(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}
+   */
+  #isValidPercentage(locale, string) {
+    const hasPercentageSymbol = this.#hasPercentage(locale, string);
+    if (!hasPercentageSymbol) {
+      return false;
+    }
+    const clearNumber = this.#getClearNumber(string);
+    return !isNaN(this.getGlobalize(locale).numberParser()(clearNumber));
+  }
+  #getClearNumber(string = '') {
+    return string.replace(new RegExp(`(^(?:${(0, _regex.getSpacePattern)()})*|(?:${(0, _regex.getSpacePattern)()})*$)`, 'g'), '').replace(/^-/, '').replace(/٪|%/g, '').trim();
+  }
+  #hasPercentage(locale, string) {
+    const baseNumber = '[0-9,. ]+';
+    let pattern;
+
+    // in persian and arabic contexts, percentage comes before the number
+    if (['fa-IR', 'fa-ir'].includes(locale) || locale.startsWith('ar')) {
+      pattern = new RegExp(`(?:-)?(?:${(0, _regex.getSpacePattern)()})?(?:٪|%)(?:${(0, _regex.getSpacePattern)()})?${baseNumber}`, 'g');
+    } else {
+      pattern = new RegExp(`(?:-)?(?:${(0, _regex.getSpacePattern)()})?${baseNumber}(?:${(0, _regex.getSpacePattern)()})?(?:٪|%)`, 'g');
+    }
+    return pattern.test(string);
+  }
+
+  /**
+   * check whether the given value is a valid percentage of default locale
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  #isDefaultPercentage(string) {
+    return this.#isValidPercentage(this.defaultLocale(), string);
+  }
+}
+exports.default = PercentageValidator;

package/dist/lib/validator/string.js

@@ -0,0 +1,172 @@
+"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 _base = _interopRequireDefault(require("./base.js"));
+var _tinyld = require("tinyld");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * String validation class
+ */
+class StringValidator extends _base.default {
+  constructor() {
+    super('string');
+  }
+
+  /**
+   *
+   * @override
+   */
+  buildConfig() {
+    const options = _config.default.getOptions();
+    this.addToConfig('mockChars', options?.qaMock);
+    this.addToConfig('resource', _config.default.getResourceBundle(), {});
+    this.addToConfig('garbledChars', _config.default.getGarbledChars()?.filter(v => String(v).trim()).filter(Boolean), []);
+  }
+
+  /**
+   *
+   * @override
+   */
+  isInternationalized(string) {
+    return this.getConfig()?.resource?.[this.defaultLocale()]?.includes(string);
+  }
+
+  /**
+   *
+   * @override
+   */
+  validate(string) {
+    return typeof string === 'string'; // add more constraints
+  }
+
+  /**
+   * to check if the string is a DNT string
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  isDntText(string) {
+    return this.getConfig()?.resource?.dnt?.includes(string);
+  }
+
+  /**
+   * to check if the string can be treated as an auto ingored string
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  isAutoIgnoredText(string) {
+    return this.isDefaultLocale() || this.isUserInputText(string) || this.isEmailText(string) || this.isUrlText(string);
+  }
+
+  /**
+   * to check if the string is an Ignored string
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  isIgnoredText(string) {
+    return this.getConfig()?.resource?.ignore?.includes(string);
+  }
+
+  /**
+   * to check if the string is a user input
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  isUserInputText(string) {
+    return string.startsWith(_constants.USER_INPUT_PRE_FIX);
+  }
+
+  /**
+   * to check if the string is a email string
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  isEmailText(string) {
+    return _constants.PATTERNS.EMAIL.test(string);
+  }
+
+  /**
+   * to check if the string is a Url string
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  isUrlText(string) {
+    return _constants.PATTERNS.URL.test(string);
+  }
+
+  /**
+   * to check if the string is fully localized in QA
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  isFullQaLanguageText(string) {
+    const config = this.getConfig();
+    return string.slice(0, 2) === config?.mockChars?.prefix && string.slice(-2) === config?.mockChars.suffix;
+  }
+
+  /**
+   * to check if the string is a DNT string
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  isPartialQaLanguageText(string) {
+    const config = this.getConfig();
+    return string.slice(0, 2) === config?.mockChars.prefix || string.slice(-2) === config?.mockChars.suffix;
+  }
+
+  /**
+   * to check if the string has encoding issues
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  hasEncodingIssue(string) {
+    return this.getConfig()?.garbledChars?.length > 0 && this.getConfig().garbledChars.some(char => string.includes(char));
+  }
+
+  /**
+   * to check if the string is a partially localized
+   *
+   * @param {String} string
+   * @returns {Promise<Boolean>}
+   */
+  isPartiallyLocalizedText(string) {
+    return this.#detectLanguageCode(string) === this.currentLanguage();
+  }
+
+  /**
+   * detects given string language code
+   * @param {String} string
+   */
+  #detectLanguageCode(string) {
+    const matches = (0, _tinyld.detectAll)(string);
+    const currLang = this.currentLanguage();
+    if (matches.length && matches.find(m => m.lang === currLang)) {
+      return currLang;
+    }
+    return this.defaultLanguage();
+  }
+
+  /**
+   * to check if the string is a fully localized
+   *
+   * @param {String} string
+   * @returns {Boolean}
+   */
+  isLocalized(string) {
+    return this.getConfig()?.resource?.[this.currentLocale()]?.includes(string);
+  }
+}
+exports.default = StringValidator;

package/dist/lib/validator/time.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 TimeValidator extends _base.default {
+  constructor() {
+    super('time');
+  }
+
+  /**
+   *
+   * @override
+   */
+  validate(string) {
+    return this.#isDefaultTime(string) || this.isInternationalized(string);
+  }
+
+  /**
+   *
+   * @override
+   */
+  isInternationalized(string) {
+    return this.#isValidTime(this.isQaLocale() ? this.defaultLocale() : this.currentLocale(), string);
+  }
+
+  /**
+   *
+   * @override
+   */
+  buildConfig() {}
+  #isValidTime(locale, string) {
+    return this.#verifyUsingGlobalize(locale, string) || this.#verifyUsingLuxon(locale, string) || this.#verifyUsingChrono(locale, string);
+  }
+  #isDefaultTime(string) {
+    return this.#isValidTime(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({
+        time: format
+      });
+      if (timeParser(string)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  #verifyUsingLuxon(locale, string) {
+    const formats = [_luxon.DateTime.TIME_SIMPLE, _luxon.DateTime.TIME_WITH_SECONDS, _luxon.DateTime.TIME_WITH_SHORT_OFFSET, _luxon.DateTime.TIME_WITH_LONG_OFFSET, _luxon.DateTime.TIME_24_SIMPLE, _luxon.DateTime.TIME_24_WITH_LONG_OFFSET, _luxon.DateTime.TIME_24_WITH_SECONDS, _luxon.DateTime.TIME_24_WITH_SHORT_OFFSET];
+    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 = TimeValidator;

package/dist/utils/2Dgraphic.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _jimp = _interopRequireDefault(require("jimp"));
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _logs = _interopRequireDefault(require("../utils/logs.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Graphic {
+  /**
+   * Draws a rectangle on an image.
+   * @param {object} eleRec - The element rectangle object.
+   * @param {string} color - The color of the rectangle border.
+   * @param {string} report_img - The path to the image file.
+   */
+  static async drawRectangle(eleRec, color, report_img) {
+    const rectX = eleRec?.x - 2;
+    const rectY = eleRec?.y - 2;
+    const rectWidth = eleRec?.width + 2;
+    const rectHeight = eleRec?.height + 2;
+    const thickness = 2;
+    try {
+      const image = await _jimp.default.read(report_img);
+      const rectangleColor = _jimp.default.cssColorToHex(color);
+      this.drawRectangleOutline(image, rectX, rectY, rectWidth, rectHeight, rectangleColor, thickness);
+      const targetDir = _path.default.dirname(report_img);
+      const buffer = await image.getBufferAsync(_jimp.default.MIME_PNG);
+      if (!_fs.default.existsSync(targetDir)) {
+        _logs.default.debug('folder not found');
+        _fs.default.mkdirSync(targetDir, {
+          recursive: true
+        });
+      }
+      _fs.default.writeFileSync(report_img, buffer);
+    } catch (err) {
+      _logs.default.error(`Error: ${err}`);
+    }
+  }
+  static async drawRectangleOutline(image, x, y, width, height, color, thickness) {
+    for (let i = x; i < x + width; i++) {
+      for (let t = 0; t < thickness; t++) {
+        image.setPixelColor(color, i, y + t);
+        image.setPixelColor(color, i, y + height - 1 - t);
+      }
+    }
+    for (let j = y; j < y + height; j++) {
+      for (let t = 0; t < thickness; t++) {
+        image.setPixelColor(color, x + t, j);
+        image.setPixelColor(color, x + width - 1 - t, j);
+      }
+    }
+  }
+}
+exports.default = Graphic;

package/dist/utils/cache.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _config = _interopRequireDefault(require("../lib/config.js"));
+var _constants = require("./constants.js");
+var _file = require("./file.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Cache {
+  static #cachePath;
+  static init(softInit = false) {
+    !softInit && Cache.recreateDir();
+    Cache.#cachePath = Cache.generatePath(_config.default.getLastRunTimeStamp());
+  }
+  static exists() {
+    return (0, _file.fileExists)(Cache.#cachePath);
+  }
+  static save(data) {
+    (0, _file.ensureDirectoryExists)(_constants.CACHE_DIR_PATH, false);
+    (0, _file.saveToFile)(Cache.#cachePath, JSON.stringify(data));
+  }
+  static getData() {
+    if (!this.exists()) {
+      return {};
+    } else {
+      try {
+        return JSON.parse((0, _file.getFileContent)(Cache.#cachePath));
+      } catch (ex) {
+        return {};
+      }
+    }
+  }
+  static recreateDir() {
+    (0, _file.deleteFile)(_constants.CACHE_DIR_PATH, true);
+    (0, _file.ensureDirectoryExists)(_constants.CACHE_DIR_PATH, false);
+  }
+  static delete() {
+    (0, _file.deleteFile)(Cache.#cachePath, true);
+  }
+  static generatePath = timeStamp => (0, _file.joinPaths)(_constants.CACHE_DIR_PATH, Cache.#generateFileName(timeStamp));
+  static #generateFileName(timeStamp) {
+    return `${Buffer.from(timeStamp).toString('base64')}.cache`;
+  }
+}
+exports.default = Cache;

package/dist/utils/common.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.propertExists = exports.arr2Txt = exports.allPropertyExists = void 0;
+const propertExists = (key, obj) => key in obj;
+exports.propertExists = propertExists;
+const allPropertyExists = (keys, obj, missingKeys = []) => keys.every(key => {
+  if (!propertExists(key, obj)) {
+    missingKeys.push(key);
+    return true;
+  }
+  return true;
+});
+exports.allPropertyExists = allPropertyExists;
+const arr2Txt = (array, demiliter = ', ') => array.join(demiliter);
+exports.arr2Txt = arr2Txt;

package/dist/utils/configFile.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateConfig = exports.readConfigFile = exports.getConfigTemplate = exports.checkAndExportConfig = void 0;
+var _common = require("./common.js");
+var _constants = require("./constants.js");
+var _file = require("./file.js");
+const getConfigFilePath = () => (0, _file.joinPaths)(process.cwd(), _constants.CONFIG_FILE_NAME);
+const getConfigTemplate = (type = '') => `{
+    "type": "${type}", // set automation framework type ${(0, _common.arr2Txt)(Object.values(_constants.SYSTEM_TYPES))}
+    "qaLocale": "", // set the qa locale used in your project
+    "l10nResourcePath": "./l10nResources", // set the dir path of l10n resources
+    "supportedLocales": ["en_US", "fr_FR", "ja_JP"], // set the list of supported locales
+    "defaultLocale": "en_US", // set default locale of the application
+    "qaMock": { // set the prefix and suffix characters of qa locale
+        "prefix": "à_",
+        "suffix": "_海"
+    },
+    "i18nVerify": true, // enable or disable I18n verification
+    "garbledChars": [""] // set the list of custom garbled characters
+}`;
+exports.getConfigTemplate = getConfigTemplate;
+const readConfigFile = () => {
+  const rcFilePath = getConfigFilePath();
+  if (!(0, _file.fileExists)(rcFilePath)) {
+    throw new Error(`${_constants.CONFIG_FILE_NAME} file is missing. Please add the file in your project root dir`);
+  }
+  let rcFile = (0, _file.getFileContent)(rcFilePath);
+  if (!rcFile) {
+    throw new Error(`invalid ${_constants.CONFIG_FILE_NAME} file. Please add valid file in your project root dir`);
+  }
+  rcFile = rcFile.replace(/\/\/.+$/gm, ''); // strip comments
+
+  try {
+    rcFile = JSON.parse(rcFile);
+  } catch (ex) {
+    throw new Error(`invalid ${_constants.CONFIG_FILE_NAME} file. Please add valid file in your project root dir`);
+  }
+  return rcFile;
+};
+exports.readConfigFile = readConfigFile;
+const validateConfig = config => {
+  if (typeof config !== 'object' || Object.keys(config).length < 1) {
+    throw new Error(`empty ${_constants.CONFIG_FILE_NAME} file`);
+  }
+
+  // add required property validations
+  const missingKeys = [];
+  if (!(0, _common.allPropertyExists)(['l10nResourcePath', 'supportedLocales', 'defaultLocale', 'type'], config, missingKeys)) {
+    throw new Error(`following properties are missing in ${_constants.CONFIG_FILE_NAME} file: ${(0, _common.arr2Txt)(missingKeys)}`);
+  }
+  if (!Object.values(_constants.SYSTEM_TYPES).includes(config?.type || '')) {
+    throw new Error(`${_constants.CONFIG_FILE_NAME} has invalid system type`);
+  }
+};
+exports.validateConfig = validateConfig;
+const checkAndExportConfig = (filePath, type = '') => {
+  if (filePath && !(0, _file.fileExists)(filePath)) {
+    (0, _file.saveToFile)(filePath, getConfigTemplate(type));
+  }
+};
+exports.checkAndExportConfig = checkAndExportConfig;