@anddone/coretestautomation 1.0.1

package/dist/utils/generationUtils.js

@@ -0,0 +1,869 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerationUtils = void 0;
+const date_fns_1 = require("date-fns");
+const date_fns_tz_1 = require("date-fns-tz");
+const fakerStaticData_1 = require("./fakerStaticData");
+class GenerationUtils {
+    /**
+         * Returns a random integer between min and max (inclusive).
+         *
+         * @param min Minimum number (inclusive)
+         * @param max Maximum number (inclusive)
+         * @returns Random number between min and max
+         *
+         * Example:
+         * randomNumber(1, 10) → 7
+         */
+    static randomNumber(min, max) {
+        try {
+            if (min > max) {
+                return 0;
+            }
+            return Math.floor(Math.random() * (max - min + 1)) + min;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Returns a random floating-point number between min and max.
+     *
+     * @param min Minimum number
+     * @param max Maximum number
+     * @param decimals Number of decimal places (default: 2)
+     * @returns Random float between min and max
+     *
+     * Example:
+     * randomFloat(1, 5, 2) → 3.47
+     */
+    static randomFloat(min, max, decimals = 2) {
+        try {
+            if (min > max) {
+                return 0;
+            }
+            const value = Math.random() * (max - min) + min;
+            return Number(value.toFixed(decimals));
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Returns a random boolean value.
+     *
+     * @returns true or false
+     *
+     * Example:
+     * randomBoolean() → true
+     */
+    static randomBoolean() {
+        try {
+            return Math.random() < 0.5;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Returns a random element from an array.
+     *
+     * @param values Array of values
+     * @returns Random element or null if array is empty
+     *
+     * Example:
+     * randomFromArray(["A", "B", "C"]) → "B"
+     */
+    static randomFromArray(values) {
+        try {
+            if (!values || values.length === 0)
+                return null;
+            const index = Math.floor(Math.random() * values.length);
+            return values[index];
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Returns a random valid index for an array.
+     *
+     * @param max Length of the array
+     * @returns Random index between 0 and max - 1
+     *
+     * Example:
+     * randomIndex(5) → 3
+     */
+    static randomIndex(max) {
+        try {
+            if (max <= 0) {
+                return 0;
+            }
+            return Math.floor(Math.random() * max);
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Returns a random alphabetic string (A–Z, a–z).
+     *
+     * @param length Length of the string
+     * @returns Random alphabetic string
+     *
+     * Example:
+     * randomAlphaString(5) → "aZxQe"
+     */
+    static randomAlphaString(length) {
+        try {
+            const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+            return this.generateRandomFromCharset(chars, length);
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random numeric string (0–9).
+     *
+     * @param length Length of the string
+     * @returns Random numeric string
+     *
+     * Example:
+     * randomNumericString(4) → "4829"
+     */
+    static randomNumericString(length) {
+        try {
+            const chars = "0123456789";
+            return this.generateRandomFromCharset(chars, length);
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random alphanumeric string (letters + numbers).
+     *
+     * @param length Length of the string
+     * @returns Random alphanumeric string
+     *
+     * Example:
+     * randomAlphaNumericString(8) → "A9bX2Lq7"
+     */
+    static randomAlphaNumericString(length) {
+        try {
+            const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+            return this.generateRandomFromCharset(chars, length);
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Internal helper to generate random string from a given character set.
+     *
+     * @param chars Allowed characters
+     * @param length Length of string
+     * @returns Random string
+     */
+    static generateRandomFromCharset(chars, length) {
+        try {
+            if (length <= 0)
+                return "";
+            let result = "";
+            for (let i = 0; i < length; i++) {
+                result += chars.charAt(Math.floor(Math.random() * chars.length));
+            }
+            return result;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random first name.
+     *
+     * @returns Random first name
+     *
+     * Example:
+     * randomFirstName() → "Rahul"
+     */
+    static randomFirstName() {
+        try {
+            return fakerStaticData_1.FIRST_NAMES[Math.floor(Math.random() * fakerStaticData_1.FIRST_NAMES.length)];
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random last name.
+     *
+     * @returns Random last name
+     *
+     * Example:
+     * randomLastName() → "Sharma"
+     */
+    static randomLastName() {
+        try {
+            return fakerStaticData_1.LAST_NAMES[Math.floor(Math.random() * fakerStaticData_1.LAST_NAMES.length)];
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random full name (first name + last name).
+     *
+     * @returns Random full name
+     *
+     * Example:
+     * randomFullName() → "Rahul Sharma"
+     */
+    static randomFullName() {
+        try {
+            return `${this.randomFirstName()} ${this.randomLastName()}`;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random username generated from name and number.
+     *
+     * @returns Random username
+     *
+     * Example:
+     * randomUsername() → "rahul.sharma482"
+     */
+    static randomUsername() {
+        try {
+            const first = this.randomFirstName().toLowerCase();
+            const last = this.randomLastName().toLowerCase();
+            const number = Math.floor(Math.random() * 1000);
+            return `${first}.${last}${number}`;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random email address.
+     *
+     * @returns Random email string
+     *
+     * Example:
+     * randomEmail() → "rahul.sharma482@gmail.com"
+     */
+    static randomEmail() {
+        try {
+            const first = this.randomFirstName().toLowerCase();
+            const last = this.randomLastName().toLowerCase();
+            const number = Math.floor(Math.random() * 1000);
+            const domain = fakerStaticData_1.EMAIL_DOMAINS[Math.floor(Math.random() * fakerStaticData_1.EMAIL_DOMAINS.length)];
+            return `${first}.${last}${number}@${domain}`;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random country calling code.
+     *
+     * @returns Country code string (e.g. "+91")
+     *
+     * Example:
+     * randomCountryCode() → "+91"
+     */
+    static randomCountryCode() {
+        try {
+            return fakerStaticData_1.COUNTRY_CODES[Math.floor(Math.random() * fakerStaticData_1.COUNTRY_CODES.length)];
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random phone number with country code.
+     *
+     * @returns Phone number string
+     *
+     * Example:
+     * randomPhoneNumber() → "+91 9876543210"
+     */
+    static randomPhoneNumber() {
+        try {
+            const countryCode = this.randomCountryCode();
+            // Generate a 10-digit phone number
+            let number = "";
+            for (let i = 0; i < 10; i++) {
+                number += Math.floor(Math.random() * 10);
+            }
+            return `${countryCode} ${number}`;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random US phone number.
+     *
+     * Format: +1 XXX-XXX-XXXX
+     *
+     * @returns US phone number string
+     *
+     * Example:
+     * getRandomUSPhoneNumber() → "+1 415-782-3490"
+     */
+    static getRandomUSPhoneNumber() {
+        try {
+            const countryCode = "+1";
+            // Area code (2–9 followed by 2 digits)
+            const areaCode = Math.floor(Math.random() * 8 + 2).toString() +
+                Math.floor(Math.random() * 10) +
+                Math.floor(Math.random() * 10);
+            // Exchange code (2–9 followed by 2 digits)
+            const exchangeCode = Math.floor(Math.random() * 8 + 2).toString() +
+                Math.floor(Math.random() * 10) +
+                Math.floor(Math.random() * 10);
+            // Line number (4 digits)
+            const lineNumber = Math.floor(1000 + Math.random() * 9000);
+            return `${countryCode} ${areaCode}-${exchangeCode}-${lineNumber}`;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Generates a random user object containing basic identity and contact details.
+     *
+     * @returns Generated fields include:
+     * - First name
+     * - Last name
+     * - Full name (first + last)
+     * - Username (lowercased name with numeric suffix)
+     * - Email address (using common email domains)
+     *
+     * - Generic phone number (with random country code)
+     * - US-specific phone number
+     */
+    static generateUserObject() {
+        try {
+            const firstName = this.randomFirstName();
+            const lastName = this.randomLastName();
+            const fullName = firstName + " " + lastName;
+            const number = Math.floor(Math.random() * 1000);
+            const username = `${firstName.toLowerCase()}.${lastName.toLowerCase()}${number}`;
+            const domain = fakerStaticData_1.EMAIL_DOMAINS[Math.floor(Math.random() * fakerStaticData_1.EMAIL_DOMAINS.length)];
+            const email = `${firstName}.${lastName}${number}@${domain}`;
+            const phoneNo = this.randomPhoneNumber();
+            const usPhone = this.getRandomUSPhoneNumber();
+            return {
+                firstName,
+                lastName,
+                fullName,
+                username,
+                email,
+                phoneNo,
+                usPhone,
+            };
+        }
+        catch {
+            return {
+                firstName: "",
+                lastName: "",
+                fullName: "",
+                username: "",
+                email: "",
+                phoneNo: "",
+                usPhone: "",
+            };
+        }
+    }
+    static generateIndiaPincode(prefix) {
+        try {
+            let pincode = prefix;
+            for (let i = 0; i < 5; i++) {
+                pincode += Math.floor(Math.random() * 10);
+            }
+            return pincode;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random India location (country, state, city).
+     *
+     * @returns Object containing country, state, and city
+     *
+     * Example:
+     * getRandomIndiaLocation()
+     * → { country: "India", state: "Karnataka", city: "Bengaluru", pincode: "560102" }
+     */
+    static getRandomIndiaLocation() {
+        try {
+            const stateObj = fakerStaticData_1.INDIA_LOCATIONS[Math.floor(Math.random() * fakerStaticData_1.INDIA_LOCATIONS.length)];
+            const city = stateObj.cities[Math.floor(Math.random() * stateObj.cities.length)];
+            const pincode = this.generateIndiaPincode(stateObj.pincodePrefix);
+            return {
+                country: "India",
+                state: stateObj.state,
+                city,
+                pincode
+            };
+        }
+        catch {
+            return {
+                country: "",
+                state: "",
+                city: "",
+                pincode: ""
+            };
+        }
+    }
+    static generateUSZipCode() {
+        try {
+            let zip = "";
+            for (let i = 0; i < 5; i++) {
+                zip += Math.floor(Math.random() * 10);
+            }
+            return zip;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random USA location (country, state, city).
+     *
+     * @returns Object containing country, state, and city
+     *
+     * Example:
+     * getRandomUSALocation()
+     * → { country: "United States", state: "California", city: "San Diego" }
+     */
+    static getRandomUSALocation() {
+        try {
+            const stateObj = fakerStaticData_1.USA_LOCATIONS[Math.floor(Math.random() * fakerStaticData_1.USA_LOCATIONS.length)];
+            const city = stateObj.cities[Math.floor(Math.random() * stateObj.cities.length)];
+            return {
+                country: "United States",
+                state: stateObj.state,
+                city,
+                zipCode: this.generateUSZipCode()
+            };
+        }
+        catch {
+            return {
+                country: "",
+                state: "",
+                city: "",
+                zipCode: ""
+            };
+        }
+    }
+    /**
+     * Returns a random address line.
+     *
+     * @returns Random address line
+     *
+     * Example:
+     * randomAddressLine() → "Flat 302, MG Road"
+     */
+    static randomAddressLine() {
+        try {
+            const buildingNumber = Math.floor(Math.random() * 900) + 100;
+            const street = fakerStaticData_1.STREET_NAMES[Math.floor(Math.random() * fakerStaticData_1.STREET_NAMES.length)];
+            return `Flat ${buildingNumber}, ${street}`;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random UUID.
+     *
+     * @returns Random UUID string
+     *
+     * Example:
+     * randomUUID() → "f47ac10b-58cc-4372-a567-0e02b2c3d479"
+     */
+    static randomUUID() {
+        try {
+            return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, char => {
+                const rand = Math.random() * 16 | 0;
+                const value = char === "x" ? rand : (rand & 0x3 | 0x8);
+                return value.toString(16);
+            });
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns a random lorem sentence.
+     *
+     * @param wordCount Optional number of words in the sentence
+     * @returns Random lorem sentence string
+     *
+     * Example:
+     * randomLoremSentence() → "Lorem ipsum dolor sit amet."
+     * randomLoremSentence(8) → "Lorem ipsum dolor sit amet consectetur elit."
+     */
+    static randomLoremSentence(wordCount = 8) {
+        try {
+            if (wordCount <= 0)
+                return "";
+            const words = [];
+            for (let i = 0; i < wordCount; i++) {
+                words.push(fakerStaticData_1.LOREM_WORDS[i % fakerStaticData_1.LOREM_WORDS.length]);
+            }
+            const sentence = words.join(" ").charAt(0).toUpperCase() +
+                words.join(" ").slice(1) +
+                ".";
+            return sentence;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Returns the current date formatted in the given timezone.
+     *
+     * @param timezone IANA timezone
+     * @param format date-fns format string
+     * @returns formatted date string
+     *
+     * Example:
+     * getCurrentDateByTimezoneFormat("Asia/Kolkata", "dd/MM/yyyy") → "07/01/2026"
+     */
+    static getCurrentDateByTimezoneFormat(timezone, format) {
+        try {
+            const currentDate = new Date();
+            return (0, date_fns_tz_1.formatInTimeZone)(currentDate, timezone, format);
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Parses a date string using the provided format.
+     *
+     * @param dateStr input date string
+     * @param format date-fns format describing the input
+     * @returns Date object if valid, otherwise null
+     *
+     * Example:
+     * parseDate("02/Jan/2003", "dd/MMM/yyyy") -> 2003-01-01T18:30:00.000Z
+     */
+    static parseDate(dateStr, format) {
+        try {
+            if (!dateStr || !format)
+                return null;
+            const parsedDate = (0, date_fns_1.parse)(dateStr, format, new Date());
+            return (0, date_fns_1.isValid)(parsedDate) ? parsedDate : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Converts a date string from one format to another.
+     *
+     * @param dateStr input date string
+     * @param inputFormat format of input string
+     * @param outputFormat desired output format
+     * @returns formatted date string or null if invalid
+     *
+     * Example:
+     * convertDateFormat("2026-01-07", "yyyy-MM-dd", "dd/MM/yyyy") → "07/01/2026"
+     */
+    static convertDateFormat(dateStr, inputFormat, outputFormat) {
+        try {
+            if (!dateStr || !inputFormat || !outputFormat)
+                return null;
+            const parsedDate = this.parseDate(dateStr, inputFormat);
+            if (parsedDate == null)
+                return null;
+            return (0, date_fns_1.format)(parsedDate, outputFormat);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Removes the time portion from a Date and normalizes it to local midnight.
+     *
+     * @param date Date object
+     * @returns Date with time set to 00:00 or null if invalid
+     *
+     * Example:
+     * normalizeToDateOnly(new Date("2026-01-07T10:30:00")) -> 2024-01-14T18:30:00.000Z
+     */
+    static normalizeToDateOnly(date) {
+        try {
+            if (!(0, date_fns_1.isValid)(date))
+                return null;
+            return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Adjusts a date by adding or subtracting days, months, and/or years.
+     *
+     * Positive values add time, negative values subtract time.
+     *
+     * @param date Base date to adjust
+     * @param options Object containing days, months, and/or years
+     * @returns Adjusted Date or null if input date is invalid
+     *
+     * Example:
+     * adjustDate(new Date(), { days: 5 })
+     * adjustDate(new Date(), { months: -2 })
+     * adjustDate(new Date(), { years: 1, days: 10 })
+     */
+    static adjustDate(date, options) {
+        try {
+            if (!(0, date_fns_1.isValid)(date))
+                return null;
+            let result = date;
+            if (options.years) {
+                result = (0, date_fns_1.addYears)(result, options.years);
+            }
+            if (options.months) {
+                result = (0, date_fns_1.addMonths)(result, options.months);
+            }
+            if (options.days) {
+                result = (0, date_fns_1.addDays)(result, options.days);
+            }
+            return result;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Adjusts the current date by adding or subtracting days, months, and/or years.
+     *
+     * Positive values add time, negative values subtract time.
+     *
+     * @param options Object containing days, months, and/or years
+     * @returns Adjusted Date or null if input date is invalid
+     *
+     * Example:
+     * adjustDate({ days: 5 })
+     * adjustDate({ months: -2 })
+     * adjustDate({ years: 1, days: 10 })
+     */
+    static adjustFromCurrentDate(options) {
+        try {
+            const date = new Date();
+            if (!(0, date_fns_1.isValid)(date))
+                return null;
+            let result = date;
+            if (options.years) {
+                result = (0, date_fns_1.addYears)(result, options.years);
+            }
+            if (options.months) {
+                result = (0, date_fns_1.addMonths)(result, options.months);
+            }
+            if (options.days) {
+                result = (0, date_fns_1.addDays)(result, options.days);
+            }
+            return result;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Extracts day, month, and year from a Date object.
+     *
+     * @param date Date object
+     * @returns {{ day: number; month: number; year: number } | null}
+     * Object containing day (1–31), month (1–12), and year
+     */
+    static getDayMonthYear(date) {
+        try {
+            if (!(date instanceof Date) || !(0, date_fns_1.isValid)(date))
+                return null;
+            return {
+                day: date.getDate(),
+                month: date.getMonth() + 1,
+                year: date.getFullYear()
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Splits a string using a string or regex delimiter.
+     *
+     * @param value Input string to split
+     * @param delimiter String or RegExp used as delimiter
+     * @returns Array of split values (trimmed, non-empty)
+     *
+     * Examples:
+     * splitByDelimiter("A,B,C", ",") → ["A", "B", "C"]
+     * splitByDelimiter("A | B | C", "|") → ["A", "B", "C"]
+     * splitByDelimiter("A,B;C|D", /[,;|]/) → ["A", "B", "C", "D"]
+     */
+    static splitByDelimiter(value, delimiter) {
+        try {
+            if (!value || !delimiter)
+                return [];
+            return value
+                .split(delimiter)
+                .map(item => item.trim())
+                .filter(item => item.length > 0);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Returns the first regex match found in a string.
+     *
+     * If the regex contains capturing groups, the full match is returned.
+     *
+     * @param value Input string
+     * @param pattern Regular expression
+     * @returns First matched string or null if no match
+     *
+     * Example:
+     * getFirstMatch("Amount: $250", /\d+/) → "250"
+     */
+    static getFirstMatch(value, pattern) {
+        try {
+            if (!value || !pattern)
+                return null;
+            const match = value.match(pattern);
+            return match ? match[0] : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Returns all matches of a regex pattern found in a string.
+     *
+     * Note: For full functionality, the regex should have the global (g) flag.
+     *
+     * @param value Input string
+     * @param pattern Regular expression (preferably with /g)
+     * @returns Array of matched strings (empty array if no matches)
+     *
+     * Example:
+     * getAllMatches("IDs: 12, 45, 78", /\d+/g) → ["12", "45", "78"]
+     */
+    static getAllMatches(value, pattern) {
+        try {
+            if (!value || !pattern)
+                return [];
+            const matches = value.match(pattern);
+            return matches ? matches : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+   * This method is to get total technology fee
+   * @since 13-01-2026
+   * @param fixedFee number
+   * @param percentageFee number
+   * @param amount number
+   * @returns number | null
+   */
+    static getTotalFees(fixedFee, percentageFee, amount) {
+        try {
+            if (isNaN(fixedFee) ||
+                isNaN(percentageFee) ||
+                isNaN(amount)) {
+                throw new Error('Invalid number input');
+            }
+            const totalTechFees = (amount / 100) * percentageFee + fixedFee;
+            return totalTechFees;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * This method is get total amount as per passed fixed & percentage fee and amount
+     * @since 13-01-2026
+     * @param fixedFee number
+     * @param percentageFee number
+     * @param amount number
+     * @returns number | null
+     */
+    static getTotalAmount(fixedFee, percentageFee, amount) {
+        try {
+            const techFee = this.getTotalFees(fixedFee, percentageFee, amount);
+            if (techFee === null) {
+                throw new Error('Fee calculation failed');
+            }
+            return techFee + amount;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Returns the difference between two dates in years.
+     *
+     * @param date1 Start date
+     * @param date2 End date
+     * @returns Difference in days or null if invalid
+     */
+    static getDifferenceInDays(date1, date2) {
+        try {
+            if (!(0, date_fns_1.isValid)(date1) || !(0, date_fns_1.isValid)(date2))
+                return null;
+            return (0, date_fns_1.differenceInDays)(date2, date1);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Returns the difference between two dates in years.
+     *
+     * @param date1 Start date
+     * @param date2 End date
+     * @returns Difference in months or null if invalid
+     */
+    static getDifferenceInMonths(date1, date2) {
+        try {
+            if (!(0, date_fns_1.isValid)(date1) || !(0, date_fns_1.isValid)(date2))
+                return null;
+            return (0, date_fns_1.differenceInMonths)(date2, date1);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Returns the difference between two dates in years.
+     *
+     * @param date1 Start date
+     * @param date2 End date
+     * @returns Difference in years or null if invalid
+     */
+    static getDifferenceInYears(date1, date2) {
+        try {
+            if (!(0, date_fns_1.isValid)(date1) || !(0, date_fns_1.isValid)(date2))
+                return null;
+            return (0, date_fns_1.differenceInYears)(date2, date1);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.GenerationUtils = GenerationUtils;
+//# sourceMappingURL=generationUtils.js.map