Mock Generator

import {
  generateNIK,
  generatePhone,
  generateNPWP,
  generatePlate,
  generateEmail,
  generateName,
  generateMockPerson,
  createMockFactory,
} from '@indodev/toolkit/mock';
 
// One-shot generation
const nik = generateNIK({ seed: 42 });        // Deterministic NIK
const phone = generatePhone({ seed: 42 });      // Deterministic phone
const person = generateMockPerson({ seed: 42 }); // Full mock person
 
// Factory for reproducible sequences
const factory = createMockFactory(12345);
const p1 = factory.generateMockPerson();
const p2 = factory.generateMockPerson();
// p1 and p2 are always the same for the same seed

// Same seed = same output
const nik1 = generateNIK({ seed: 42 });
const nik2 = generateNIK({ seed: 42 });
console.log(nik1 === nik2); // true — always identical

// Without seed — different each time
generateNIK();  // Different every call
generateNIK();  // Different every call

function generateNIK(options?: NIKMockOptions): string;

// Random NIK
generateNIK();  // '3212012903850001'
 
// Deterministic with seed
generateNIK({ seed: 42 });  // Always same output
 
// Specific gender and date
generateNIK({ gender: 'F', birthDate: new Date('1990-05-15'), seed: 1 });
// '3201019005550001'  (day 15 + 40 = 55 for female)
 
// Specific province
generateNIK({ provinceCode: '31', seed: 1 });
// '3101019005550001'  (31 = DKI Jakarta)

function generatePhone(options?: PhoneMockOptions): string;

// Random phone in national format
generatePhone();  // '08123456789'
 
// International format
generatePhone({ format: 'international', seed: 1 });  // '+628123456789'
 
// Specific operator
generatePhone({ operator: 'Telkomsel', seed: 1 });  // '08123456789'

function generateNPWP(options?: NPWPMockOptions): string;

// Raw format (15-16 digits)
generateNPWP();  // '012345678901234'
 
// Formatted
generateNPWP({ format: 'formatted', seed: 1 });  // '01.234.567.8-901.234'

function generatePlate(options?: PlateMockOptions): string;

generatePlate();  // 'B 1234 ABC'
 
generatePlate({ region: 'D', seed: 1 });  // 'D 5678 XY'

function generateEmail(options?: EmailMockOptions): string;

generateEmail();  // 'agus@gmail.com'
 
generateEmail({ domain: 'yahoo.co.id', seed: 1 });  // 'budi@yahoo.co.id'
 
// Same seed produces same email
generateEmail({ seed: 42 });  // Always same
generateEmail({ seed: 42 });  // Always same

function generateName(options?: NameMockOptions): string;

// Full name
generateName();  // 'Budi Santoso'
generateName({ gender: 'F' });  // 'Siti Rahayu'
 
// First name only
generateName({ parts: 'first', seed: 1 });  // 'Agus'
 
// Last name only
generateName({ parts: 'last', seed: 1 });  // 'Santoso'

function generateMockPerson(options?: MockPersonOptions): MockPerson;

interface MockPerson {
  name: string;           // Full name
  gender: 'M' | 'F';      // Consistent across fields
  birthDate: string;      // ISO 8601: 'YYYY-MM-DD'
  nik: string;            // Passes validateNIK()
  npwp: string;           // Passes validateNPWP()
  phone: string;          // Passes validatePhoneNumber()
  email: string;          // Passes validateEmail()
  plate: string;          // Passes validatePlate()
}

const person = generateMockPerson({ seed: 42 });
// {
//   name: 'Agus Santoso',
//   gender: 'M',
//   birthDate: '1985-03-15',
//   nik: '3201018503150001',
//   npwp: '012345678901234',
//   phone: '08123456789',
//   email: 'agus@gmail.com',
//   plate: 'B 1234 ABC'
// }
 
// Female with specific gender
const female = generateMockPerson({ gender: 'F', seed: 1 });
// Gender is consistent: NIK encodes female day, name uses female list

function createMockFactory(seed: number): MockFactory;

const factory = createMockFactory(12345);
 
const p1 = factory.generateMockPerson();
const p2 = factory.generateMockPerson();
const p3 = factory.generateNIK();
 
// All deterministic — same seed = same output
// Every time you create factory with 12345, you get same sequence

type MockGender = 'M' | 'F';

type PhoneOperator = 'Telkomsel' | 'XL' | 'Indosat' | 'Axis' | 'Tri' | 'Smartfren';

type PhoneFormat = 'national' | 'international' | 'e164';

type NPWPFormat = 'formatted' | 'raw';

type PlateType = 'private' | 'public';

type NameParts = 'first' | 'last' | 'full';

interface NIKMockOptions {
  gender?: MockGender;
  birthDate?: Date;
  provinceCode?: string;
  seed?: number;
}

interface MockPersonOptions {
  gender?: MockGender;
  seed?: number;
}

interface MockFactory {
  generateNIK(options?: Omit<NIKMockOptions, 'seed'>): string;
  generatePhone(options?: Omit<PhoneMockOptions, 'seed'>): string;
  generateNPWP(options?: Omit<NPWPMockOptions, 'seed'>): string;
  generatePlate(options?: Omit<PlateMockOptions, 'seed'>): string;
  generateEmail(options?: Omit<EmailMockOptions, 'seed'>): string;
  generateName(options?: Omit<NameMockOptions, 'seed'>): string;
  generateMockPerson(options?: Omit<MockPersonOptions, 'seed'>): MockPerson;
}

const nik = generateNIK({ seed: 42 });
validateNIK(nik);  // true — always passes
 
const phone = generatePhone({ seed: 42 });
validatePhoneNumber(phone);  // true — always passes