@playq/core 0.2.77

package/dist/helper/bundle/vars.js

@@ -0,0 +1,375 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValue = getValue;
+exports.getConfigValue = getConfigValue;
+exports.setValue = setValue;
+exports.replaceVariables = replaceVariables;
+exports.debugVars = debugVars;
+exports.parseLooseJson = parseLooseJson;
+exports.loadFileEntries = loadFileEntries;
+exports.initVars = initVars;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let importedVars = {};
+const patternDirs = [
+    path.resolve(process.env.PLAYQ_PROJECT_ROOT || process.cwd(), "resources/patterns"),
+    path.resolve(process.env.PLAYQ_PROJECT_ROOT || process.cwd(), "extend/addons/pattern"),
+];
+const storedVars = {};
+const loggedMissingKeys = new Set();
+function getValue(key, ifEmpty) {
+    if (!key) {
+        console.warn("⚠️ Empty key provided to getValue");
+        return ifEmpty ? "" : key;
+    }
+    key = key.trim();
+    if (key.startsWith("env.")) {
+        const envKey = key.slice(4);
+        const envValue = process.env[envKey];
+        if (!envValue) {
+            return ifEmpty ? "" : key;
+        }
+        return envValue;
+    }
+    if (key in storedVars)
+        return (ifEmpty && storedVars[key] === key) ? "" : storedVars[key];
+    // Only log when this is not an existence check
+    if (!ifEmpty && !loggedMissingKeys.has(key)) {
+        console.warn(`⚠️ Variable not found for key: "${key}"`);
+        loggedMissingKeys.add(key);
+    }
+    return ifEmpty ? "" : key;
+}
+function getConfigValue(key, ifEmpty) {
+    // Support environment variable overrides using PLAYQ__ dotted path mapping.
+    // Example: config.browser.browserType -> PLAYQ__browser__browserType
+    const rawKey = key.trim();
+    const envKey = 'PLAYQ__' + rawKey.replace(/\./g, '__');
+    if (process.env[envKey])
+        return process.env[envKey];
+    const fullKey = 'config.' + rawKey;
+    if (fullKey in storedVars)
+        return storedVars[fullKey];
+    if (!loggedMissingKeys.has(fullKey)) {
+        loggedMissingKeys.add(fullKey);
+        if (ifEmpty)
+            return '';
+    }
+    return fullKey;
+}
+function setValue(key, value) {
+    storedVars[key] = value;
+    if (key.startsWith("var.static.")) {
+        updateVarStaticJson(key.slice(11), value);
+    }
+}
+function updateVarStaticJson(key, value) {
+    const jsonFilePath = path.resolve(process.cwd(), "resources/var.static.json");
+    let data = {};
+    // Read existing file if it exists
+    if (fs.existsSync(jsonFilePath)) {
+        try {
+            const fileContent = fs.readFileSync(jsonFilePath, "utf-8");
+            data = JSON.parse(fileContent);
+            console.log(`📖 Existing data:`, data); // Debug log
+        }
+        catch (error) {
+            console.warn(`Warning: Could not parse existing var.static.json:`, error.message);
+            data = {};
+        }
+    }
+    else {
+        console.log(`📝 Creating new var.static.json file`);
+    }
+    // Store old value for comparison
+    const oldValue = data[key];
+    // Update or add the key-value pair
+    data[key] = value;
+    console.log(`🔄 Updating key "${key}": "${oldValue}" → "${value}"`); // Debug log
+    console.log(`📦 Final data:`, data); // Debug log
+    // Ensure the directory exists
+    const dir = path.dirname(jsonFilePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    // Write the updated data back to the file
+    try {
+        fs.writeFileSync(jsonFilePath, JSON.stringify(data, null, 2), "utf-8");
+        if (oldValue !== undefined) {
+            console.log(`✅ Updated var.static.json: ${key} = ${value} (was: ${oldValue})`);
+        }
+        else {
+            console.log(`✅ Added to var.static.json: ${key} = ${value}`);
+        }
+    }
+    catch (error) {
+        console.error(`❌ Failed to write to var.static.json:`, error.message);
+        throw error;
+    }
+}
+function replaceVariables(input) {
+    if (typeof input !== "string")
+        input = input.toString();
+    return input.replace(/\#\{([^}]+)\}/g, (_, varName) => {
+        if (varName.startsWith("pwd.")) {
+            const encryptedValue = varName.replace(/^pwd\./, "");
+            try {
+                const crypto = require("../util/utilities/cryptoUtil");
+                return crypto.decrypt(encryptedValue);
+            }
+            catch (error) {
+                console.warn('Warning: Could not decrypt pwd value:', error.message);
+                return varName;
+            }
+        }
+        else if (varName.startsWith("enc.")) {
+            const encryptedValue = varName.replace(/^enc\./, "");
+            try {
+                const crypto = require("../util/utilities/cryptoUtil");
+                return crypto.decrypt(encryptedValue);
+            }
+            catch (error) {
+                console.warn('Warning: Could not decrypt enc value:', error.message);
+                return varName;
+            }
+        }
+        if (varName.endsWith(".(toNumber)")) {
+            const baseVar = varName.replace(".(toNumber)", "");
+            const value = getValue(baseVar);
+            return value !== undefined && value !== null && value !== ""
+                ? Number(value)
+                : "";
+        }
+        return getValue(varName);
+    });
+}
+function debugVars() {
+    console.log("📦 Static Vars:", storedVars);
+}
+function flattenConfig(obj, prefix = "config") {
+    const entries = {};
+    for (const key in obj) {
+        const fullKey = `${prefix}.${key}`;
+        if (typeof obj[key] === "object" && obj[key] !== null && !Array.isArray(obj[key])) {
+            Object.assign(entries, flattenConfig(obj[key], fullKey));
+        }
+        else if (Array.isArray(obj[key])) {
+            entries[fullKey] = obj[key].join(";");
+        }
+        else {
+            entries[fullKey] = String(obj[key]);
+        }
+    }
+    return entries;
+}
+function loadPatternEntries() {
+    var _a;
+    const files = [];
+    for (const dir of patternDirs) {
+        if (fs.existsSync(dir)) {
+            try {
+                const dirFiles = fs
+                    .readdirSync(dir)
+                    .filter((file) => {
+                    const isTS = file.endsWith(".pattern.ts");
+                    const isAddonDir = dir.includes("extend/addons/pattern");
+                    if (!isTS)
+                        return false;
+                    if (isAddonDir)
+                        return file.startsWith("_");
+                    return !file.startsWith("_");
+                })
+                    .map((file) => path.join(dir, file));
+                files.push(...dirFiles);
+            }
+            catch (error) {
+                console.warn(`Warning: Could not read pattern directory ${dir}:`, error.message);
+            }
+        }
+    }
+    for (const file of files) {
+        try {
+            const fileName = path.basename(file, ".pattern.ts");
+            if (!/^[a-zA-Z0-9_]+$/.test(fileName)) {
+                console.warn(`❌ Invalid pattern file name "${fileName}". Only alphanumeric characters and underscores are allowed.`);
+                continue;
+            }
+            delete require.cache[require.resolve(file)];
+            const patternModule = require(file);
+            const exported = patternModule[fileName] || ((_a = patternModule.default) === null || _a === void 0 ? void 0 : _a[fileName]);
+            if (!exported) {
+                console.warn(`❌ Exported const '${fileName}' not found in: ${file}`);
+                continue;
+            }
+            const flattened = flattenConfig(exported, `pattern.${fileName}`);
+            Object.assign(storedVars, flattened);
+        }
+        catch (error) {
+            console.warn(`Warning: Could not load pattern file ${file}:`, error.message);
+        }
+    }
+}
+function loadFileEntries(file, constName, prefix) {
+    console.log(`🔍 Loading file: ${file} with constName: ${constName} and prefix: ${prefix}`);
+    const absPath = path.isAbsolute(file) ? file : path.resolve(process.cwd(), file);
+    if (!fs.existsSync(absPath)) {
+        throw new Error(`❌ Load file not found: ${absPath}`);
+    }
+    const ext = path.extname(absPath);
+    let data;
+    if (ext === ".ts" || ext === ".js") {
+        delete require.cache[require.resolve(absPath)];
+        const module = require(absPath);
+        data = module[constName] || (module.default && module.default[constName]) || module.default || module;
+        if (!data) {
+            throw new Error(`❌ Exported const '${constName}' not found in: ${file}`);
+        }
+    }
+    else if (ext === ".json") {
+        data = JSON.parse(fs.readFileSync(absPath, "utf-8"));
+    }
+    else {
+        throw new Error(`❌ Unsupported file extension: ${ext}`);
+    }
+    const flat = flattenConfig(data, prefix || "");
+    Object.assign(storedVars, flat);
+}
+function resolveModulePath(basePath) {
+    const candidates = [".ts", ".js", ".mjs", ".cjs", ".json"];
+    for (const ext of candidates) {
+        const candidate = basePath + ext;
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return basePath; // fall back to base (may still resolve via require paths)
+}
+function parseLooseJson(str) {
+    if (!str || str.trim() === "" || str.trim() === '""')
+        return {};
+    const needsBraces = !str.trim().startsWith("{") || !str.trim().endsWith("}");
+    let wrappedStr = needsBraces ? `{${str}}` : str;
+    try {
+        const locatorRegex = /(["']?locator["']?\s*:\s*)(xpath=[^,\}\n\r]+|css=[^,\}\n\r]+|chain=[^,\}\n\r]+)/g;
+        const locatorPlaceholders = [];
+        let maskedStr = wrappedStr.replace(locatorRegex, (match, p1, p2) => {
+            locatorPlaceholders.push(`"${p2.trim()}"`);
+            return `${p1}__LOCATOR_PLACEHOLDER_${locatorPlaceholders.length - 1}__`;
+        });
+        maskedStr = maskedStr.replace(/:\s*'((?:[^']|\\')*)'/g, (match, p1) => {
+            return `: "${p1}"`;
+        });
+        let normalized = maskedStr
+            .replace(/([{,]\s*)([a-zA-Z0-9_]+)\s*:/g, '$1"$2":')
+            .replace(/:\s*True\b/g, ": true")
+            .replace(/:\s*False\b/g, ": false")
+            .replace(/:\s*None\b/g, ": null")
+            .replace(/,(\s*[}\]])/g, "$1");
+        locatorPlaceholders.forEach((value, index) => {
+            normalized = normalized.replace(`__LOCATOR_PLACEHOLDER_${index}__`, value);
+        });
+        return JSON.parse(normalized);
+    }
+    catch (err) {
+        throw new Error(`❌ Failed to parse options string: "${str}". Error: ${err.message}`);
+    }
+}
+function loadDefaults() {
+    try {
+        // defaultEntries sits next to this file; load it relatively to avoid env/path issues
+        const { default: defaultEntries } = require('./defaultEntries');
+        if (Array.isArray(defaultEntries)) {
+            defaultEntries.forEach((item) => {
+                let value = getValue('env.' + item.name, true) ? getValue('env.' + item.name) : (getValue(item.name, true) ? getValue(item.name) : item.value);
+                setValue(item.name, value);
+            });
+        }
+    }
+    catch (error) {
+        console.warn('Warning: Could not load default entries:', error.message);
+    }
+}
+function initVars(vars) {
+    try {
+        // Load config with error handling
+        let configEntries = {};
+        try {
+            const importConfigBase = path.resolve(process.env.PLAYQ_PROJECT_ROOT, 'resources/config');
+            const importConfigPath = resolveModulePath(importConfigBase);
+            console.log('🔎 [core] Requiring config from:', importConfigPath);
+            const configModule = require(importConfigPath);
+            configEntries = configModule.config || configModule.default || {};
+        }
+        catch (error) {
+            console.warn('Warning: Could not load config file, using empty config');
+        }
+        // Load static variables preferring resources/var.static.json
+        let variablesEntries = {};
+        const varStaticPath = path.resolve(process.env.PLAYQ_PROJECT_ROOT, 'resources/var.static.json');
+        if (fs.existsSync(varStaticPath)) {
+            try {
+                console.log('🔎 [core] Loading var.static.json:', varStaticPath);
+                const fileContent = fs.readFileSync(varStaticPath, 'utf-8');
+                variablesEntries = JSON.parse(fileContent) || {};
+            }
+            catch (error) {
+                console.warn('Warning: Could not parse var.static.json, using empty variables:', error.message);
+            }
+        }
+        else {
+            // Fallback to legacy resources/variable module if present
+            try {
+                const importVariableBase = path.resolve(process.env.PLAYQ_PROJECT_ROOT, 'resources/variable');
+                const importVariablePath = resolveModulePath(importVariableBase);
+                console.log('🔎 [core] Requiring legacy variable module from:', importVariablePath);
+                const variableModule = require(importVariablePath);
+                variablesEntries = variableModule.var_static || variableModule.default || {};
+            }
+            catch (error) {
+                console.warn('Warning: Could not load variable file (var.static.json or legacy module), using empty variables');
+            }
+        }
+        if (vars) {
+            Object.assign(storedVars, vars);
+        }
+        Object.assign(storedVars, flattenConfig(variablesEntries, "var.static"));
+        Object.assign(storedVars, flattenConfig(configEntries, "config"));
+        loadPatternEntries();
+        loadDefaults();
+    }
+    catch (error) {
+        console.error('Error initializing vars:', error.message);
+    }
+}

package/dist/helper/faker/customFaker.d.ts

@@ -0,0 +1,55 @@
+import { faker as baseFaker } from '@faker-js/faker';
+export declare const faker: typeof baseFaker & {
+    custom: {
+        passport: (options?: {
+            countryCode?: string;
+        }) => string;
+        mobile: {
+            number: (options?: {
+                countryCode?: string;
+                dialCodePrefix?: boolean;
+            }) => string;
+        };
+        postcode: {
+            get: (options?: {
+                countryCode?: string;
+                stateCode?: string;
+            }) => string;
+        };
+        person: {
+            fullName: (options?: {
+                gender?: "male" | "female";
+                withPrefix?: boolean;
+                maxLength?: number;
+            }) => string;
+            birthDate: (options?: {
+                min?: number;
+                max?: number;
+                year?: number;
+                format?: "DD-MM-YYYY" | "MM-DD-YYYY" | "YYYY-MM-DD" | "DD/MM/YYYY" | "MM/DD/YYYY" | "YYYY/MM/DD" | "DD-MM-YY" | "MM-DD-YY" | "YY-MM-DD" | "DD/MM/YY" | "MM/DD/YY" | "YY/MM/DD";
+            }) => string;
+        };
+        nric: {
+            generate: (options?: {
+                prefix?: "S" | "T" | "F" | "G";
+                yearOfBirth?: number;
+            }) => string;
+            getYear: (nric: string) => string;
+        };
+        datetime: {
+            /**
+             *
+             * @param options Eg: {'format': 'DD/MM/YYYY HH:mm:ss'}, {'format': 'YY-MM-DD HH.mm'}
+             * @returns
+             */
+            generateCurrentDateTime: (options?: {
+                format?: string;
+            }) => string;
+            addMonthsToDate: (dateStr: string, months: number | string, options?: {
+                inputFormat?: "DD-MM-YYYY" | "MM-DD-YYYY" | "YYYY-MM-DD" | "DD/MM/YYYY" | "MM/DD/YYYY" | "YYYY/MM/DD" | "DD-MM-YY" | "MM-DD-YY" | "YY-MM-DD" | "DD/MM/YY" | "MM/DD/YY" | "YY/MM/DD";
+                outputFormat?: "DD-MM-YYYY" | "MM-DD-YYYY" | "YYYY-MM-DD" | "DD/MM/YYYY" | "MM/DD/YYYY" | "YYYY/MM/DD" | "DD-MM-YY" | "MM-DD-YY" | "YY-MM-DD" | "DD/MM/YY" | "MM/DD/YY" | "YY/MM/DD";
+                clampToLastDayOfMonth?: boolean;
+            }) => string;
+        };
+    };
+};

package/dist/helper/faker/customFaker.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.faker = void 0;
+// src/helper/faker/customFaker.ts
+const faker_1 = require("@faker-js/faker");
+const passport_1 = require("./modules/passport");
+const mobile_1 = require("./modules/mobile");
+const postcode_1 = require("./modules/postcode");
+const person_1 = require("./modules/person");
+const nric_1 = require("./modules/nric");
+const dateTime_1 = require("./modules/dateTime");
+faker_1.faker.custom = {
+    passport: passport_1.generatePassportNumber,
+    mobile: {
+        number: mobile_1.generateMobileNumber
+    },
+    postcode: {
+        get: postcode_1.getValidPostCode
+    },
+    person: {
+        fullName: person_1.generatePersonFullName,
+        birthDate: person_1.generateBirthDate
+    },
+    nric: {
+        generate: nric_1.generateNRIC,
+        getYear: nric_1.getYearFromNRIC
+    },
+    datetime: {
+        generateCurrentDateTime: dateTime_1.generateCurrentDateTime,
+        addMonthsToDate: dateTime_1.addMonthsToDate
+    }
+};
+exports.faker = faker_1.faker;
+// // src/helper/faker/customFaker.ts
+// import { faker as baseFaker } from '@faker-js/faker';
+// import { generatePassportNumber } from './modules/passport';
+// import { generateMobileNumber } from './modules/mobile';
+// (baseFaker as any).passport = {
+//   number: generatePassportNumber
+// };
+// export const faker = baseFaker as typeof baseFaker & {
+//   passport: {
+//     number: (countryCode?: string) => string;
+//   };
+// };

package/dist/helper/faker/modules/data/postcodes_valid_sg.json

@@ -0,0 +1,17 @@
+[
+    "018937", "049318", "049320", "049712", "059819", "068808", "078867", "089680",
+    "098585", "138632", "169208", "178957", "179097", "179098", "188021", "189559",
+    "199588", "238882", "238883", "238884", "238885", "238887", "238888",
+    "259569", "259571", "259772", "259775", "259776", "259778", "259779",
+    "269713", "269716", "269717", "269719", "269720", "269722", "269725", "269726",
+    "279116", "279118", "279119", "279121", "279122", "279124", "279125", "279126",
+    "307987", "308232", "308275", "308276", "308278", "339511",
+    "408600", "408601", "408604", "408605", "408606", "408607",
+    "469976", "469977", "469978", "469979", "469980", "469981", "469982", "469983",
+    "499936", "499938", "499939", "499941", "499942", "499943",
+    "568020", "568021", "568022", "568023", "568024", "568025", "568026", "568027",
+    "579799", "579800", "579801", "579804", "579806",
+    "608545", "608546", "608547", "608548", "608549", "608550", "608551", "608552",
+    "757869", "757870", "757871", "757872", "757873", "757874", "757875", "757876",
+    "819642", "819643", "819645", "819646", "819647", "819648", "819649"
+]

package/dist/helper/faker/modules/dateTime.d.ts

@@ -0,0 +1,18 @@
+interface CurrentDateTimeOptions {
+    format?: string;
+}
+export declare function generateCurrentDateTime(options?: CurrentDateTimeOptions): string;
+interface AddMonthsOptions {
+    inputFormat?: 'DD-MM-YYYY' | 'MM-DD-YYYY' | 'YYYY-MM-DD' | 'DD/MM/YYYY' | 'MM/DD/YYYY' | 'YYYY/MM/DD' | 'DD-MM-YY' | 'MM-DD-YY' | 'YY-MM-DD' | 'DD/MM/YY' | 'MM/DD/YY' | 'YY/MM/DD';
+    outputFormat?: 'DD-MM-YYYY' | 'MM-DD-YYYY' | 'YYYY-MM-DD' | 'DD/MM/YYYY' | 'MM/DD/YYYY' | 'YYYY/MM/DD' | 'DD-MM-YY' | 'MM-DD-YY' | 'YY-MM-DD' | 'DD/MM/YY' | 'MM/DD/YY' | 'YY/MM/DD';
+    clampToLastDayOfMonth?: boolean;
+}
+export declare function addMonthsToDate(dateStr: string, months: number | string, options?: AddMonthsOptions): string;
+/**
+ * Removes leading zeros from both the day and month in a date string of format DD/MM/YYYY.
+ * Example: '03/07/2025' => '3/7/2025'
+ * @param dateStr - The date string in DD/MM/YYYY format
+ * @returns The date string with leading zeros removed from day and month
+ */
+export declare function removeLeadingZeroFromMonthAndDate(dateStr: string): string;
+export {};

package/dist/helper/faker/modules/dateTime.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCurrentDateTime = generateCurrentDateTime;
+exports.addMonthsToDate = addMonthsToDate;
+exports.removeLeadingZeroFromMonthAndDate = removeLeadingZeroFromMonthAndDate;
+function generateCurrentDateTime(options = {}) {
+    const { format = 'DD-MM-YYYY HH:mm:ss' } = options;
+    const date = new Date();
+    const dd = String(date.getDate()).padStart(2, '0');
+    const mm = String(date.getMonth() + 1).padStart(2, '0');
+    const yyyy = date.getFullYear();
+    const yy = String(yyyy).slice(-2);
+    const hh = String(date.getHours()).padStart(2, '0');
+    const min = String(date.getMinutes()).padStart(2, '0');
+    const ss = String(date.getSeconds()).padStart(2, '0');
+    // Replace tokens in format string
+    let result = format;
+    result = result.replace(/DD/g, dd)
+        .replace(/MM/g, mm)
+        .replace(/YYYY/g, String(yyyy))
+        .replace(/YY/g, yy)
+        .replace(/HH/g, hh)
+        .replace(/mm/g, min)
+        .replace(/ss/g, ss);
+    return result;
+}
+function parseDate(dateStr, format) {
+    const sep = format.includes('/') ? '/' : '-';
+    const parts = dateStr.split(sep);
+    let day = 1, month = 0, year = 1970;
+    switch (format) {
+        case 'DD-MM-YYYY':
+        case 'DD/MM/YYYY':
+            [day, month, year] = [parseInt(parts[0]), parseInt(parts[1]) - 1, parseInt(parts[2])];
+            break;
+        case 'MM-DD-YYYY':
+        case 'MM/DD/YYYY':
+            [month, day, year] = [parseInt(parts[0]) - 1, parseInt(parts[1]), parseInt(parts[2])];
+            break;
+        case 'YYYY-MM-DD':
+        case 'YYYY/MM/DD':
+            [year, month, day] = [parseInt(parts[0]), parseInt(parts[1]) - 1, parseInt(parts[2])];
+            break;
+        case 'DD-MM-YY':
+        case 'DD/MM/YY':
+            [day, month, year] = [parseInt(parts[0]), parseInt(parts[1]) - 1, 2000 + parseInt(parts[2])];
+            break;
+        case 'MM-DD-YY':
+        case 'MM/DD/YY':
+            [month, day, year] = [parseInt(parts[0]) - 1, parseInt(parts[1]), 2000 + parseInt(parts[2])];
+            break;
+        case 'YY-MM-DD':
+        case 'YY/MM/DD':
+            [year, month, day] = [2000 + parseInt(parts[0]), parseInt(parts[1]) - 1, parseInt(parts[2])];
+            break;
+        default:
+            throw new Error('Unsupported input format');
+    }
+    return new Date(year, month, day);
+}
+function formatDate(date, format) {
+    const dd = String(date.getDate()).padStart(2, '0');
+    const mm = String(date.getMonth() + 1).padStart(2, '0');
+    const yyyy = date.getFullYear();
+    const yy = String(yyyy).slice(-2);
+    switch (format) {
+        case 'YYYY-MM-DD': return `${yyyy}-${mm}-${dd}`;
+        case 'YYYY/MM/DD': return `${yyyy}/${mm}/${dd}`;
+        case 'MM-DD-YYYY': return `${mm}-${dd}-${yyyy}`;
+        case 'MM/DD/YYYY': return `${mm}/${dd}/${yyyy}`;
+        case 'DD/MM/YYYY': return `${dd}/${mm}/${yyyy}`;
+        case 'DD-MM-YYYY': return `${dd}-${mm}-${yyyy}`;
+        case 'DD-MM-YY': return `${dd}-${mm}-${yy}`;
+        case 'MM-DD-YY': return `${mm}-${dd}-${yy}`;
+        case 'YY-MM-DD': return `${yy}-${mm}-${dd}`;
+        case 'DD/MM/YY': return `${dd}/${mm}/${yy}`;
+        case 'MM/DD/YY': return `${mm}/${dd}/${yy}`;
+        case 'YY/MM/DD': return `${yy}/${mm}/${dd}`;
+        default: return `${dd}/${mm}/${yy}`;
+    }
+}
+function getLastDayOfMonth(year, month) {
+    return new Date(year, month + 1, 0).getDate();
+}
+function addMonthsToDate(dateStr, months, options = {}) {
+    const inputFormat = options.inputFormat || 'DD-MM-YY';
+    const outputFormat = options.outputFormat || 'DD-MM-YY';
+    const clamp = options.clampToLastDayOfMonth || false;
+    const date = parseDate(dateStr, inputFormat);
+    const originalDay = date.getDate();
+    const monthsNum = typeof months === 'string' ? parseInt(months, 10) : months;
+    date.setMonth(date.getMonth() + monthsNum);
+    if (clamp && date.getDate() !== originalDay) {
+        date.setDate(0);
+    }
+    return formatDate(date, outputFormat);
+}
+/**
+ * Removes leading zeros from both the day and month in a date string of format DD/MM/YYYY.
+ * Example: '03/07/2025' => '3/7/2025'
+ * @param dateStr - The date string in DD/MM/YYYY format
+ * @returns The date string with leading zeros removed from day and month
+ */
+function removeLeadingZeroFromMonthAndDate(dateStr) {
+    return dateStr.replace(/\b0(\d)/g, "$1");
+}

package/dist/helper/faker/modules/mobile.d.ts

@@ -0,0 +1,4 @@
+export declare function generateMobileNumber(options?: {
+    countryCode?: string;
+    dialCodePrefix?: boolean;
+}): string;