@playq/core 0.2.77

package/src/helper/faker/customFaker.ts

@@ -0,0 +1,107 @@
+// src/helper/faker/customFaker.ts
+import { faker as baseFaker } from '@faker-js/faker';
+import { generatePassportNumber } from './modules/passport';
+import { generateMobileNumber } from './modules/mobile';
+import { getValidPostCode } from './modules/postcode';
+import { generatePersonFullName, generateBirthDate } from './modules/person';
+import { generateNRIC,getYearFromNRIC } from './modules/nric';
+import { generateCurrentDateTime, addMonthsToDate } from './modules/dateTime'; 
+
+(baseFaker as any).custom = {
+  passport: generatePassportNumber,
+  mobile: {
+    number: generateMobileNumber
+  },
+  postcode: {
+    get: getValidPostCode
+  },
+  person: {
+    fullName: generatePersonFullName,
+    birthDate: generateBirthDate
+  },
+  nric: {
+    generate: generateNRIC,
+    getYear: getYearFromNRIC
+  },
+  datetime: {
+    generateCurrentDateTime : generateCurrentDateTime,
+    addMonthsToDate: addMonthsToDate
+  }
+};
+
+export const faker = baseFaker as 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;
+    };  
+
+
+        
+    
+  };
+  // mobile: {
+  //   number: (countryCode?: string, withCountryCode?: boolean) => string;
+  // };
+
+  // postcode: {
+  //   valid: {
+  //     get: (countryCode?: string,stateCode?: string) => string;
+  //   };
+  // };
+};
+
+
+// // 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/src/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/src/helper/faker/modules/dateTime.ts

@@ -0,0 +1,121 @@
+import { faker } from '@faker-js/faker';
+
+
+interface CurrentDateTimeOptions {
+  format?: string;
+}
+
+export function generateCurrentDateTime(options: CurrentDateTimeOptions = {}): string {
+  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;
+}
+
+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;
+}
+
+function parseDate(dateStr: string, format: string): Date {
+  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: Date, format: string): string {
+  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: number, month: number): number {
+  return new Date(year, month + 1, 0).getDate();
+}
+
+export function addMonthsToDate(
+  dateStr: string,
+  months: number | string,
+  options: AddMonthsOptions = {}
+): string {
+  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
+ */
+export function removeLeadingZeroFromMonthAndDate(dateStr: string): string {
+  return dateStr.replace(/\b0(\d)/g, "$1");
+}

package/src/helper/faker/modules/mobile.ts

@@ -0,0 +1,58 @@
+// src/helper/faker/modules/mobile.ts
+import { faker } from "@faker-js/faker";
+
+export function generateMobileNumber(options?: {countryCode?: string, dialCodePrefix?: boolean}): string {
+  const {countryCode = 'AU', dialCodePrefix = true } = options || {};
+  switch (countryCode.toUpperCase()) {
+    case "AU": {
+      const prefix = "04";
+      const digits = faker.string.numeric(8);
+      return dialCodePrefix ? `+61${prefix.slice(1)}${digits}` : `${prefix}${digits}`;
+    }
+    case "SG": {
+      const allowedPrefixes = ["855","955"];
+      const prefix = faker.helpers.arrayElement(allowedPrefixes);
+      const digits = faker.string.numeric(5);
+      return dialCodePrefix ? `+65${prefix}${digits}` : `${prefix}${digits}`;
+    }
+    case "IN": {
+      const allowedPrefixes = ["6", "7", "8", "9"];
+      const prefix = faker.helpers.arrayElement(allowedPrefixes);
+      const digits = faker.string.numeric(9);
+      return dialCodePrefix ? `+91${prefix}${digits}` : `${prefix}${digits}`;
+    }
+    case "US": {
+      const allowedPrefixes = ["2", "3", "4", "5", "6", "7", "8", "9"];
+      const prefix = faker.helpers.arrayElement(allowedPrefixes);
+      const digits = faker.string.numeric(7);
+      return dialCodePrefix ? `+1${prefix}${digits}` : `${prefix}${digits}`;
+    }
+    case "UK": {
+      const allowedPrefixes = ["7", "8", "9"];
+      const prefix = faker.helpers.arrayElement(allowedPrefixes);
+      const digits = faker.string.numeric(8);
+      return dialCodePrefix ? `+44${prefix}${digits}` : `${prefix}${digits}`;
+    }
+    case "CA": {
+      const allowedPrefixes = ["2", "3", "4", "5", "6", "7", "8", "9"];
+      const prefix = faker.helpers.arrayElement(allowedPrefixes);
+      const digits = faker.string.numeric(7);
+      return dialCodePrefix ? `+1${prefix}${digits}` : `${prefix}${digits}`;
+    }
+    case "NZ": {
+      const allowedPrefixes = ["2", "3", "4", "5", "6", "7", "8", "9"];
+      const prefix = faker.helpers.arrayElement(allowedPrefixes);
+      const digits = faker.string.numeric(7);
+      return dialCodePrefix ? `+64${prefix}${digits}` : `${prefix}${digits}`;
+    }
+    case "PH": {
+      const allowedPrefixes = ["8", "9"];
+      const prefix = faker.helpers.arrayElement(allowedPrefixes);
+      const digits = faker.string.numeric(7); 
+      return dialCodePrefix ? `+63${prefix}${digits}` : `${prefix}${digits}`;
+    }        
+
+    default:
+      throw new Error(`Unsupported country code: ${countryCode}`);
+  }
+}

package/src/helper/faker/modules/nric.ts

@@ -0,0 +1,109 @@
+import { faker } from '@faker-js/faker';
+/**
+ * Generate a valid Singapore NRIC or FIN number according to official NRIC/FIN checksum rules.
+ *
+ * Rules:
+ *  - The prefix is 'S' or 'T' for Singaporeans/PRs, 'F' or 'G' for foreigners.
+ *  - 'S' and 'F' are for those registered before 2000, 'T' and 'G' for 2000 and after.
+ *  - The 7 digits: first two are year of birth/registration, next five are random.
+ *  - The checksum character is calculated using weights [2,7,6,5,4,3,2] and a modulo-11 algorithm.
+ *  - For 'T' and 'G', add 4 to the sum before modulo.
+ *  - The checksum character set differs for citizen/PR ('S','T') and foreigner ('F','G') prefixes.
+ * See: https://en.wikipedia.org/wiki/National_Registration_Identity_Card#Structure
+ */
+/**
+ * Options for NRIC generation.
+ */
+export interface NRICOptions {
+  prefix?: string;
+  yearOfBirth?: number;
+}
+const ST_CHECKSUM_CHARS = ["J", "Z", "I", "H", "G", "F", "E", "D", "C", "B", "A"];
+const FG_CHECKSUM_CHARS = ["X", "W", "U", "T", "R", "Q", "P", "N", "M", "L", "K"];
+
+function calculateNRICChecksum(prefix: string, digits: string): string {
+  const WEIGHTS = [2, 7, 6, 5, 4, 3, 2];
+  const digitArr = digits.split('').map(Number);
+  let sum = digitArr.reduce((acc, digit, idx) => acc + digit * WEIGHTS[idx], 0);
+  if (prefix === 'T' || prefix === 'G') {
+    sum += 4;
+  }
+  const remainder = sum % 11;
+  if (prefix === 'S' || prefix === 'T') {
+    return ST_CHECKSUM_CHARS[remainder];
+  } else {
+    return FG_CHECKSUM_CHARS[remainder];
+  }
+}
+
+/**
+ * Generate a valid Singapore NRIC or FIN number according to official NRIC/FIN checksum rules.
+ * @param options - Options for NRIC generation.
+ * @returns A valid NRIC string.
+ */
+export function generateNRIC(options: NRICOptions = {}): string {
+  let { prefix, yearOfBirth } = options;
+    yearOfBirth = yearOfBirth ? Number(yearOfBirth) : undefined;
+
+  if (typeof yearOfBirth === 'number' && yearOfBirth > new Date().getFullYear()) {
+    throw new Error(`❌ yearOfBirth ${yearOfBirth} is in the future.`);
+  }
+
+  let resolvedPrefix: string;
+
+  if (prefix) {
+    resolvedPrefix = prefix;
+  } else if (typeof yearOfBirth === 'number') {
+    resolvedPrefix = yearOfBirth >= 2000 ? 'T' : 'S';
+  } else {
+    resolvedPrefix = faker.helpers.arrayElement(['S', 'T', 'F', 'G']);
+  }
+
+  if (!['S', 'T', 'F', 'G'].includes(resolvedPrefix)) {
+    console.warn(`⚠️ Invalid prefix "${resolvedPrefix}" — choosing random valid prefix.`);
+    resolvedPrefix = faker.helpers.arrayElement(['S', 'T', 'F', 'G']);
+  }
+
+    let digits: string;
+    if (typeof yearOfBirth === 'number') {
+    const yearDigits = String(yearOfBirth).slice(-2);
+    const randomDigits = faker.string.numeric({ length: 5, allowLeadingZeros: true });
+    digits = `${yearDigits}${randomDigits}`;
+    } else {
+    digits = faker.string.numeric({ length: 7, allowLeadingZeros: true });
+    }  const checksum = calculateNRICChecksum(resolvedPrefix, digits);
+
+  return `${resolvedPrefix}${digits}${checksum}`;
+}
+
+/**
+    Function to extract the year from an NRIC number
+    @param nric - The NRIC number as a string
+    @returns The year of birth as a number, or null if the NRIC is invalid
+ */
+function getYearFromNRIC(nric: string): number | null {
+  if (!/^[STFG]\d{7}[A-Z]$/.test(nric)) {
+    console.warn(`❌ Invalid NRIC format: ${nric}`);
+    return null;
+  }
+
+  const prefix = nric.charAt(0).toUpperCase();
+  const yearDigits = parseInt(nric.slice(1, 3), 10);
+
+  if (isNaN(yearDigits)) return null;
+
+  switch (prefix) {
+    case "S": // Born before 2000 (Singaporean)
+    case "F": // Foreigner before 2000
+      return 1900 + yearDigits;
+
+    case "T": // Born in or after 2000 (Singaporean)
+    case "G": // Foreigner in or after 2000
+      return 2000 + yearDigits;
+
+    default:
+      return null;
+  }
+}
+
+export {  getYearFromNRIC };

package/src/helper/faker/modules/passport.ts

@@ -0,0 +1,34 @@
+// src/helper/faker/modules/passport.ts
+import { faker } from "@faker-js/faker";
+
+export function generatePassportNumber(options?: {countryCode?: string}): string {
+  const {countryCode = 'AU'} = options;
+  switch (countryCode.toUpperCase()) {
+    case "IN":
+      return `${faker.string.alpha({
+        length: 1,
+        casing: "upper",
+      })}${faker.string.numeric(7)}`;
+    case "UK":
+      return `${faker.string.alpha({
+        length: 2,
+        casing: "upper",
+      })}${faker.string.numeric(7)}`;
+    case "US":
+      return faker.string.numeric(9);
+    case "AU": {
+      const allowedPrefixes = ["PA","PB","PC","PD","PE","PF","PU","PW","PX","PZ"];
+      const prefix = faker.helpers.arrayElement(allowedPrefixes);
+      const digits = faker.string.numeric(7);
+      return `${prefix}${digits}`;
+    }
+    case "SG": {
+      const allowedPrefixes = ["E", "K", "S"];
+      const prefix = faker.helpers.arrayElement(allowedPrefixes);
+      const digits = faker.string.numeric(7);
+      return `${prefix}${digits}`;
+    }
+    default:
+      throw new Error(`Unsupported country code: ${countryCode}`);
+  }
+}

package/src/helper/faker/modules/person.ts

@@ -0,0 +1,93 @@
+import { faker } from '@faker-js/faker';
+
+interface PersonNameOptions {
+  gender?: 'male' | 'female';
+  withPrefix?: boolean;
+  maxLength?: number;
+}
+
+export function generatePersonFullName(options: PersonNameOptions = {}): string {
+  const { gender, withPrefix = false, maxLength } = options;
+
+  let firstName = faker.person.firstName(gender);
+  let lastName = faker.person.lastName(gender);
+  let fullName = withPrefix
+    ? `${faker.person.prefix(gender)} ${firstName} ${lastName}`
+    : `${firstName} ${lastName}`;
+
+  if (maxLength && fullName.length > maxLength) {
+    // Try trimming last name first, then first name
+    lastName = lastName.slice(0, Math.max(1, Math.floor((maxLength - firstName.length - 1))));
+    fullName = withPrefix
+      ? `${faker.person.prefix(gender)} ${firstName} ${lastName}`
+      : `${firstName} ${lastName}`;
+
+    if (fullName.length > maxLength) {
+      firstName = firstName.slice(0, Math.max(1, maxLength - lastName.length - 1));
+      fullName = withPrefix
+        ? `${faker.person.prefix(gender)} ${firstName} ${lastName}`
+        : `${firstName} ${lastName}`;
+    }
+  }
+
+  return fullName.replace(/-/g, ' ');
+}
+
+interface BirthDateOptions {
+  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';
+}
+
+export function generateBirthDate(options: BirthDateOptions = {}): string {
+  const { min = 18, max = 65, year, format = 'DD-MM-YYYY' } = options;
+  let date: Date;
+  // const date = faker.date.birthdate({ min, max, mode: 'age' });
+  if (year) {
+    // Generate a random date in the given year
+    const month = faker.number.int({ min: 0, max: 11 });
+    const day = faker.number.int({ min: 1, max: 28 }); // Safe for all months
+    date = new Date(year, month, day);
+  } else {
+    date = faker.date.birthdate({ min, max, mode: 'age' });
+  }
+
+  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}-${yyyy}`;
+  }
+}

package/src/helper/faker/modules/postcode.ts

@@ -0,0 +1,57 @@
+// src/helper/faker/modules/passport.ts
+import { faker } from "@faker-js/faker";
+import validSGPostcodes from "./data/postcodes_valid_sg.json";
+
+interface PostCodeOptions {
+  countryCode?: string;
+  stateCode?: string;
+}
+
+
+export function getValidPostCode(options: PostCodeOptions = {}): string {
+  // export function getValidPostCode(countryCode: string = "AU", stateCode?: string): string {
+  const { countryCode = "AU", stateCode = "" } = options;
+
+
+  switch (countryCode.toUpperCase()) {
+    case "SG": {
+      return faker.helpers.arrayElement(validSGPostcodes);
+    }
+    
+    case "AU":
+      const AU_STATE_RANGES: Record<string, [number, number]> = {
+        "NSW": [2000, 2999],
+        "ACT": [2600, 2639],
+        "VIC": [3000, 3999],
+        "QLD": [4000, 4999],
+        "SA": [5000, 5799],
+        "WA": [6000, 6797],
+        "TAS": [7000, 7799],
+        "NT": [800, 899]
+      };
+      if (stateCode) {
+        const range = AU_STATE_RANGES[stateCode.toUpperCase()];
+        if (!range) {
+          throw new Error(`Unsupported state code: ${stateCode}`);
+        }
+        const [min, max] = range;
+        const postcodeLength = max.toString().length;
+        const postcode = faker.number.int({ min, max }).toString().padStart(postcodeLength, '0');
+        return postcode;
+      }
+      // If no state is specified, choose a random state and generate a postcode
+      const randomState = faker.helpers.arrayElement(Object.keys(AU_STATE_RANGES));
+      const [min, max] = AU_STATE_RANGES[randomState];
+      const postcodeLength = max.toString().length;
+      const postcode = faker.number.int({ min, max }).toString().padStart(postcodeLength, '0');
+      return postcode;
+
+
+    default:
+      throw new Error(`Unsupported country code: ${countryCode}`);
+  }
+
+
+ 
+}
+

package/src/helper/fixtures/locAggregate.ts

@@ -0,0 +1,61 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Dynamically builds the `loc` namespace from the consumer project.
+ * - Scans PLAYQ_PROJECT_ROOT/resources/locators for *.loc.ts or *.ts files
+ * - Imports each module (requires ts-node registration in the child process)
+ * - Collects named exports and default object keys into a single namespace
+ */
+export function getLocNamespace(): Record<string, any> {
+  const base = safeProjectRoot();
+  const dir = path.resolve(base, 'resources/locators');
+  const out: Record<string, any> = {};
+
+  if (!fs.existsSync(dir)) {
+    // Not an error—project may not provide locators
+    return out;
+  }
+
+  const files = fs.readdirSync(dir)
+    .filter(f => f.endsWith('.ts') || f.endsWith('.js'))
+    .map(f => path.join(dir, f));
+
+  for (const file of files) {
+    try {
+      // Clear module cache to reflect changes between runs
+      delete require.cache[require.resolve(file)];
+      const mod = require(file);
+
+      // Prefer named exports: export const lambdatest = {...}
+      for (const key of Object.keys(mod)) {
+        if (key === 'default') continue;
+        out[key] = mod[key];
+      }
+
+      // If default export is an object (e.g., { lambdatest: {...} }), merge keys
+      const def = mod.default;
+      if (def && typeof def === 'object') {
+        for (const [k, v] of Object.entries(def)) {
+          // Do not overwrite explicitly named exports
+          if (!(k in out)) out[k] = v;
+        }
+      }
+    } catch (e: any) {
+      console.warn(`⚠️ Failed to load loc module ${file}:`, e?.message || e);
+    }
+  }
+
+  return out;
+}
+
+function safeProjectRoot(): string {
+  if (process.env.PLAYQ_PROJECT_ROOT) return process.env.PLAYQ_PROJECT_ROOT;
+  // Walk up to find a package.json as fallback
+  let current = process.cwd();
+  while (current !== path.dirname(current)) {
+    if (fs.existsSync(path.join(current, 'package.json'))) return current;
+    current = path.dirname(current);
+  }
+  return process.cwd();
+}