@playq/core 0.2.77

package/src/helper/util/stepHelpers.ts

@@ -0,0 +1,14 @@
+import { vars } from '../../global';
+
+export async function attachResolvedStep(thisArg: any, template: string) {
+  const resolved = vars.replaceVariables(template);
+  await thisArg.attach(`🧾 Resolved Step: ${resolved}`, 'text/plain');
+}
+
+export function defineLoggedStep(pattern: string, implementation: Function) {
+  return function (this: any, ...args: any[]) {
+    const stepText = pattern.replace(/\{param\}/g, (_match, i) => `"${args[i]}"`);
+    attachResolvedStep.call(this, stepText);
+    return implementation.apply(this, args);
+  };
+}

package/src/helper/util/test-data/dataLoader.ts

@@ -0,0 +1,108 @@
+import fs from 'fs';
+import path from 'path';
+import * as XLSX from '@e965/xlsx';
+
+/**
+ * Reads test data from .json, .xlsx, or .csv
+ *
+ * @param file - Filename WITH extension, e.g., "login.json", "login.xlsx", "login.csv"
+ * @param sheetName - (optional) Sheet name for Excel files
+ */
+export function getTestData(file: string, sheetName?: string): any[] {
+  // Attempt to locate the project's test-data directory robustly.
+  // Strategy:
+  // 1. Starting at process.cwd(), walk upward looking for a folder that
+  //    contains a package.json (project root) and a test-data subfolder.
+  // 2. If found, use <foundRoot>/test-data/<file>.
+  // 3. Otherwise, fallback to process.cwd()/test-data/<file> and report a clear ENOENT.
+
+  function findProjectRootWithTestData(startDir: string): string | null {
+    let current = path.resolve(startDir);
+    const root = path.parse(current).root;
+    while (true) {
+      const pkg = path.join(current, 'package.json');
+      const td = path.join(current, 'test-data');
+      if (fs.existsSync(pkg) && fs.existsSync(td) && fs.statSync(td).isDirectory()) {
+        return td;
+      }
+      if (current === root) break;
+      current = path.dirname(current);
+    }
+    return null;
+  }
+
+  const start = process.cwd();
+  const projectTestData = findProjectRootWithTestData(start);
+
+  // If not found by walking upward, also check immediate subdirectories of the
+  // current directory. This handles the common developer workspace layout where
+  // the workspace root contains multiple project folders (e.g. PlayQ_PROJECT).
+  let basePath: string;
+  if (projectTestData) {
+    basePath = projectTestData;
+  } else {
+    // scan one-level children for a project that contains package.json and test-data
+    const children = fs.readdirSync(start, { withFileTypes: true });
+    let found: string | null = null;
+    for (const child of children) {
+      if (!child.isDirectory()) continue;
+      const candidate = path.join(start, child.name);
+      const pkg = path.join(candidate, 'package.json');
+      const td = path.join(candidate, 'test-data');
+      try {
+        if (fs.existsSync(pkg) && fs.existsSync(td) && fs.statSync(td).isDirectory()) {
+          found = td;
+          break;
+        }
+      } catch (e) {
+        // ignore permission or stat errors on non-readable dirs
+      }
+    }
+    basePath = found || path.resolve(process.cwd(), 'test-data');
+  }
+
+  const filePath = path.join(basePath, file);
+
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`ENOENT: test data file not found: ${filePath}. Searched from ${start}`);
+  }
+  const ext = path.extname(file).toLowerCase();
+
+  switch (ext) {
+    case '.json': {
+      const raw = fs.readFileSync(filePath, 'utf-8');
+      return JSON.parse(raw);
+    }
+    case '.xlsx': {
+        const workbook = XLSX.readFile(filePath);
+        const sheet = workbook.Sheets[sheetName || workbook.SheetNames[0]];
+        const rows = XLSX.utils.sheet_to_json<Record<string, any>>(sheet, { raw: false });
+
+        // Try to parse booleans/numbers
+        return rows.map(row => {
+          const parsedRow: Record<string, any> = {};
+          for (const key in row) {
+            const value = row[key];
+            if (value === 'true' || value === 'false') {
+              parsedRow[key] = value === 'true';
+            } else if (!isNaN(value) && value.trim() !== '') {
+              parsedRow[key] = Number(value);
+            } else {
+              parsedRow[key] = value;
+            }
+          }
+          return parsedRow;
+        });
+      // const workbook = XLSX.readFile(filePath);
+      // const sheet = workbook.Sheets[sheetName || workbook.SheetNames[0]];
+      // return XLSX.utils.sheet_to_json(sheet);
+    }
+    case '.csv': {
+      const fileData = fs.readFileSync(filePath, 'utf-8');
+      const worksheet = XLSX.read(fileData, { type: 'string' }).Sheets['Sheet1'];
+      return XLSX.utils.sheet_to_json(worksheet);
+    }
+    default:
+      throw new Error(`Unsupported file extension: ${ext}`);
+  }
+}

package/src/helper/util/test-data/dataTest.ts

@@ -0,0 +1,191 @@
+// dataTest.ts
+import { test } from '@playwright/test';
+import { getTestData } from './dataLoader';
+import * as vars from '../../bundle/vars';
+import { faker as coreFaker } from '../../faker/customFaker';
+
+type DataSource<T> = T[] | {
+  file: string;
+  filter?: string;
+  sheet?: string;
+  testType?: string;
+  suffix?: string; // Optional suffix for test name
+};
+
+export function dataTest<T extends Record<string, any>>(
+  label: string,
+  dataSource: T[] | { file: string; filter?: string; sheet?: string ; testType?: string; suffix?: string },
+  callback: (args: { row: T; page?: any }) => Promise<void>
+) {
+  let dataset: T[] = [];
+  const { testType = "UI", suffix = ""} = typeof dataSource === "object" && !Array.isArray(dataSource) ? dataSource : {};
+
+  if (Array.isArray(dataSource)) {
+    dataset = applyRowReplacements(dataSource as any);
+  } else {
+    let { file, filter, sheet } = dataSource;
+    file = vars.replaceVariables(file);
+    sheet = (sheet) ? vars.replaceVariables(sheet) : undefined;
+    filter = vars.replaceVariables(filter);
+    const raw = getTestData(file, sheet);
+    // Expand faker/variable placeholders within each row before filtering/scheduling tests
+    const preprocessed = applyRowReplacements(raw as any);
+    dataset = filter
+      ? (preprocessed as T[]).filter(row => {
+          try {
+            // Create a scoped function where row keys are destructured
+            const fn = new Function("row", `
+              const { ${Object.keys(row).join(", ")} } = row;
+              return ${filter};
+            `);
+            return fn(row);
+          } catch (err) {
+            console.warn(`⚠️ Filter failed: ${filter}`, err);
+            return false;
+          }
+        })
+      : (preprocessed as T[]);
+  }
+  
+  test.describe(label, () => {
+    dataset.forEach((row, index) => {
+      vars.setValue('playq.iteration.count',`${index + 1}`);
+      const name = `${label} ${vars.replaceVariables(replaceIterationDataVars(suffix,row))} [-${index + 1}-]`;
+      if (testType.toUpperCase() === "API") {
+        test(name, async () => {
+          test.info().annotations.push({ type: "tag", description: label });
+          await callback({ row });
+        });
+      } else {
+        test(name, async ({ page }) => {
+          test.info().annotations.push({ type: "tag", description: label });
+          await callback({ row, page });
+        });
+      }
+    });
+  });
+}
+
+// ----------------- helpers -----------------
+function applyRowReplacements<T extends Record<string, any>>(rows: T[]): T[] {
+  return rows.map((row) => {
+    const out: Record<string, any> = { ...row };
+    for (const k of Object.keys(out)) {
+      const v = out[k];
+      if (typeof v === 'string') {
+        // First, evaluate any faker placeholders
+        const withFaker = replaceFakerPlaceholders(v);
+        // Then, apply generic variable replacements
+        out[k] = typeof withFaker === 'string' ? vars.replaceVariables(withFaker) : withFaker;
+      }
+    }
+    return out as T;
+  });
+}
+
+function replaceFakerPlaceholders(input: string): any {
+  const trimmed = input.trim();
+  // Entire value is wrapped: #{faker....}
+  const wrapped = trimmed.match(/^#\{(faker(?:\.[a-zA-Z0-9_]+)+\((.*)\))\}$/);
+  if (wrapped) {
+    return evalFakerCall(wrapped[1]);
+  }
+  // Entire value is a faker call: faker....
+  const full = trimmed.match(/^faker((?:\.[a-zA-Z0-9_]+)+)\((.*)\)$/);
+  if (full) {
+    return evalFakerFromParts(full[1], full[2]);
+  }
+  // Embedded placeholders inside a larger string
+  return input.replace(/#\{faker((?:\.[a-zA-Z0-9_]+)+)\((.*?)\)\}/g, (_m, pathPart, argsRaw) => {
+    try {
+      const val = evalFakerFromParts(pathPart, argsRaw);
+      return String(val);
+    } catch (e) {
+      console.warn(`⚠️ Failed to evaluate faker placeholder: #{faker${pathPart}(${argsRaw})}`, e);
+      return _m;
+    }
+  });
+}
+
+function evalFakerCall(expr: string): any {
+  // expr like: faker.xxx.yyy(args)
+  const m = expr.match(/^faker((?:\.[a-zA-Z0-9_]+)+)\((.*)\)$/);
+  if (!m) throw new Error(`Invalid faker expression: ${expr}`);
+  return evalFakerFromParts(m[1], m[2]);
+}
+
+function evalFakerFromParts(pathPart: string, argsRaw: string): any {
+  const path = pathPart.replace(/^\./, '');
+  const parts = path.split('.');
+  // Prefer global faker set up by core; fall back to imported one
+  let ctx: any = (globalThis as any).faker || coreFaker;
+  let fn: any = ctx;
+  for (const p of parts) {
+    fn = fn?.[p];
+  }
+  if (typeof fn !== 'function') throw new Error(`Resolved faker path is not a function: faker.${path}`);
+  const args = parseFakerArgs(argsRaw);
+  return fn(...args);
+}
+
+function parseFakerArgs(argsRaw: string): any[] {
+  const trimmed = (argsRaw || '').trim();
+  if (!trimmed) return [];
+  if (trimmed.startsWith('{')) {
+    // Object literal; normalize to JSON
+    const normalized = trimmed
+      .replace(/([{,]\s*)([a-zA-Z0-9_]+)\s*:/g, '$1"$2":')
+      .replace(/'/g, '"');
+    try {
+      return [JSON.parse(normalized)];
+    } catch (e) {
+      throw new Error(`Failed to parse faker argument object: ${argsRaw}`);
+    }
+  }
+  // Simple comma-separated values (strip surrounding quotes)
+  return splitArgs(trimmed).map(a => a.trim().replace(/^(["'])(.*)\1$/, '$2'));
+}
+
+function splitArgs(s: string): string[] {
+  const out: string[] = [];
+  let buf = '';
+  let depth = 0;
+  let quote: '"' | "'" | null = null;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (quote) {
+      if (ch === quote && s[i - 1] !== '\\') {
+        quote = null;
+      }
+      buf += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch as any;
+      buf += ch;
+      continue;
+    }
+    if (ch === '{' || ch === '[' || ch === '(') depth++;
+    if (ch === '}' || ch === ']' || ch === ')') depth--;
+    if (ch === ',' && depth === 0) {
+      out.push(buf);
+      buf = '';
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf) out.push(buf);
+  return out;
+}
+
+/**
+ * Replaces all #{playq.iteration.data.KEY} in the input string with the value from the row object.
+ * @param input The string containing placeholders.
+ * @param row The row object with data.
+ * @returns The string with placeholders replaced.
+ */
+ function replaceIterationDataVars(input: string, row: Record<string, any>): string {
+  return input.replace(/#\{playq\.iteration\.data\.([a-zA-Z0-9_]+)\}/g, (_, key) => {
+    return row[key] !== undefined ? String(row[key]) : '';
+  });
+}

package/src/helper/util/test-data/registerUser.json

@@ -0,0 +1,7 @@
+{
+    "firstName": "Koushik ",
+    "lastName": "C ",
+    "userName": "user",
+    "password": "Pass123$",
+    "confirmPassword": "Pass123$"
+}

package/src/helper/util/totp/totpHelper.ts

@@ -0,0 +1,102 @@
+import { authenticator } from 'otplib';
+import * as QRCode from 'qrcode';
+
+export class TOTPHelper {
+    private secret: string;
+    private serviceName: string;
+    private accountName: string;
+
+    constructor(secret?: string, serviceName: string = 'PlayQ', accountName: string = 'automation') {
+        this.secret = secret || this.generateSecret();
+        this.serviceName = serviceName;
+        this.accountName = accountName;
+        
+        // Configure otplib options
+        authenticator.options = {
+            window: 2, // Allow 2 time steps tolerance
+            step: 30   // 30-second time step
+        };
+    }
+
+    /**
+     * Generate a new TOTP secret
+     */
+    generateSecret(): string {
+        return authenticator.generateSecret();
+    }
+
+    /**
+     * Generate current TOTP token
+     */
+    generateToken(): string {
+        return authenticator.generate(this.secret);
+    }
+
+    /**
+     * Verify TOTP token
+     */
+    verifyToken(token: string): boolean {
+        return authenticator.verify({
+            token,
+            secret: this.secret
+        });
+    }
+
+    /**
+     * Get OTP Auth URL for QR code generation
+     */
+    getOtpAuthUrl(): string {
+        return authenticator.keyuri(
+            this.accountName,
+            this.serviceName,
+            this.secret
+        );
+    }
+
+    /**
+     * Generate QR code for authenticator app setup
+     */
+    async generateQRCode(): Promise<string> {
+        const otpAuthUrl = this.getOtpAuthUrl();
+        return await QRCode.toDataURL(otpAuthUrl);
+    }
+
+    /**
+     * Get the secret (for environment variable storage)
+     */
+    getSecret(): string {
+        return this.secret;
+    }
+
+    /**
+     * Check if current time is near token expiry
+     */
+    getTimeRemaining(): number {
+        const epoch = Math.round(Date.now() / 1000.0);
+        const timeStep = 30;
+        return timeStep - (epoch % timeStep);
+    }
+
+    /**
+     * Generate token with retry logic for time window
+     */
+    async generateTokenWithRetry(maxRetries: number = 3): Promise<string> {
+        let attempts = 0;
+        
+        while (attempts < maxRetries) {
+            const timeRemaining = this.getTimeRemaining();
+            
+            // If token expires soon, wait for new window
+            if (timeRemaining < 5) {
+                console.log(`Token expires in ${timeRemaining}s, waiting for new window...`);
+                await new Promise(resolve => setTimeout(resolve, (timeRemaining + 1) * 1000));
+            }
+            
+            const token = this.generateToken();
+            console.log(`Generated TOTP token: ${token.substring(0, 3)}*** (${this.getTimeRemaining()}s remaining)`);
+            return token;
+        }
+        
+        throw new Error('Failed to generate TOTP token after retries');
+    }
+}

package/src/helper/util/utilities/cryptoUtil.ts

@@ -0,0 +1,53 @@
+// src/utils/cryptoUtil.ts
+import crypto from 'crypto';
+import dotenv from 'dotenv';
+
+dotenv.config();
+const algorithm = 'aes-256-gcm';
+const secretKey = crypto.scryptSync(process.env.PLAYQ_SECRET_KEY || '_DEFAULT_SECRET_32_CHARACTERS_!_', 'salt', 32);
+const ivLength = 12; // Recommended IV size for GCM
+
+export function encrypt(plaintext: string): string {
+  const iv = crypto.randomBytes(ivLength);
+  const cipher = crypto.createCipheriv(algorithm, secretKey, iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  const combined = Buffer.concat([iv, authTag, encrypted]);
+  return combined.toString('base64').replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+}
+
+export function decrypt(data: string): string {
+  const combined = Buffer.from(data.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
+  const iv = combined.subarray(0, ivLength);
+  const authTag = combined.subarray(ivLength, ivLength + 16);
+  const encrypted = combined.subarray(ivLength + 16);
+  const decipher = crypto.createDecipheriv(algorithm, secretKey, iv);
+  decipher.setAuthTag(authTag);
+  const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+  return decrypted.toString('utf8');
+}
+
+// const algorithm = 'aes-256-cbc';
+// const secretKey = process.env.CRYPTO_SECRET_KEY || '_DEFAULT_SECRET_32_CHARACTERS_!_';
+// const ivLength = 16; // AES block size
+
+// // --- Encrypt ---
+// export function encrypt(text: string): string {
+//   const iv = crypto.randomBytes(ivLength);
+//   const cipher = crypto.createCipheriv(algorithm, Buffer.from(secretKey, 'utf-8'), iv);
+//   let encrypted = cipher.update(text, 'utf8', 'hex');
+//   encrypted += cipher.final('hex');
+//   return iv.toString('hex') + ':' + encrypted;
+// }
+
+// // --- Decrypt ---
+// export function decrypt(encryptedText: string): string {
+//   const [ivHex, encrypted] = encryptedText.split(':');
+//   if (!ivHex || !encrypted) throw new Error('Invalid encrypted text format.');
+
+//   const iv = Buffer.from(ivHex, 'hex');
+//   const decipher = crypto.createDecipheriv(algorithm, Buffer.from(secretKey, 'utf-8'), iv);
+//   let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+//   decrypted += decipher.final('utf8');
+//   return decrypted;
+// }

package/src/helper/util/utilities/schemaGeneratorUtil.ts

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/* PlayQ OpenAPI (OAS 3.1) -> schema TS files generator */
+
+import fs from "node:fs";
+import path from "node:path";
+
+type OpenApiDoc = {
+  openapi: string;
+  components?: {
+    schemas?: Record<string, any>;
+  };
+};
+
+type Args = {
+  input?: string;
+  url?: string;
+  outDir: string;
+  prefix: string;
+  indexFile: string;
+};
+
+function parseArgs(argv: string[]): Args {
+  const args: Args = {
+    outDir: "resources/schemas",
+    prefix: "", // optional export prefix e.g. "Api"
+    indexFile: "index.ts",
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const v = argv[i + 1];
+
+    if (a === "--input" && v) { args.input = v; i++; continue; }
+    if (a === "--url" && v) { args.url = v; i++; continue; }
+    if (a === "--outDir" && v) { args.outDir = v; i++; continue; }
+    if (a === "--prefix" && v) { args.prefix = v; i++; continue; }
+    if (a === "--indexFile" && v) { args.indexFile = v; i++; continue; }
+  }
+
+  if (!args.input && !args.url) {
+    throw new Error(`Provide either --input <path-to-openapi.json> OR --url <openapi-json-url>`);
+  }
+  if (args.input && args.url) {
+    throw new Error(`Use only one of --input or --url (not both).`);
+  }
+  return args;
+}
+
+async function loadOpenApi(args: Args): Promise<OpenApiDoc> {
+  if (args.input) {
+    const p = path.resolve(args.input);
+    const raw = fs.readFileSync(p, "utf8");
+    return JSON.parse(raw);
+  }
+
+  // URL
+  const res = await fetch(args.url!, {
+    headers: { Accept: "application/json" },
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to fetch OpenAPI JSON from ${args.url}. HTTP ${res.status}`);
+  }
+  return (await res.json()) as OpenApiDoc;
+}
+
+function safeIdent(name: string): string {
+  // Make a valid TS identifier-ish name (keeps underscores)
+  const cleaned = name.replace(/[^a-zA-Z0-9_]/g, "_");
+  // Avoid leading digit
+  if (/^\d/.test(cleaned)) return "_" + cleaned;
+  return cleaned;
+}
+
+function exportNameFor(schemaName: string, prefix: string): string {
+  // AgentVersion -> AgentVersionSchema, optional prefix -> ApiAgentVersionSchema
+  const base = `${schemaName}Schema`;
+  return prefix ? `${prefix}${base}` : base;
+}
+
+function ensureOutDir(outDir: string) {
+  fs.mkdirSync(outDir, { recursive: true });
+}
+
+function writeSchemaFile(outDir: string, schemaKey: string, exportName: string, schema: any, openapiVersion: string) {
+  const fileName = `${schemaKey}.schema.ts`;
+  const fullPath = path.join(outDir, fileName);
+
+  const content =
+    `/* Auto-generated by PlayQ schema generator - OpenAPI ${openapiVersion} */\n` +
+    `/* Source schema: #/components/schemas/${schemaKey} */\n\n` +
+    `export const ${exportName} = ${JSON.stringify(schema, null, 2)} as const;\n`;
+
+  fs.writeFileSync(fullPath, content, "utf8");
+}
+
+function writeIndexFile(outDir: string, indexFile: string, entries: Array<{ schemaKey: string; exportName: string }>) {
+  const fullPath = path.join(outDir, indexFile);
+  const lines = entries
+    .sort((a, b) => a.schemaKey.localeCompare(b.schemaKey))
+    .map(e => `export { ${e.exportName} } from "./${e.schemaKey}.schema";`);
+
+  fs.writeFileSync(fullPath, lines.join("\n") + "\n", "utf8");
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const doc = await loadOpenApi(args);
+
+  if (!doc.openapi?.startsWith("3.1")) {
+    // still might work, but you said OAS 3.1 and this generator assumes that
+    console.warn(`⚠️ OpenAPI version is "${doc.openapi}". Generator is optimised for 3.1.x.`);
+  }
+
+  const schemas = doc.components?.schemas ?? {};
+  const schemaKeys = Object.keys(schemas);
+  if (!schemaKeys.length) {
+    throw new Error(`No components.schemas found in the OpenAPI document.`);
+  }
+
+  const outDir = path.resolve(args.outDir);
+  ensureOutDir(outDir);
+
+  const indexEntries: Array<{ schemaKey: string; exportName: string }> = [];
+
+  for (const rawKey of schemaKeys) {
+    const schemaKey = safeIdent(rawKey);
+    const exportName = exportNameFor(schemaKey, args.prefix);
+    const schema = schemas[rawKey];
+
+    writeSchemaFile(outDir, schemaKey, exportName, schema, doc.openapi);
+    indexEntries.push({ schemaKey, exportName });
+  }
+
+  writeIndexFile(outDir, args.indexFile, indexEntries);
+
+  console.log(`✅ Generated ${schemaKeys.length} schemas into: ${outDir}`);
+  console.log(`✅ Barrel export: ${path.join(outDir, args.indexFile)}`);
+}
+
+main().catch(err => {
+  console.error(`❌ ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+});

package/src/helper/util/utils.ts

@@ -0,0 +1,28 @@
+// Utilities for Test Automation
+
+function toCamelCase(input: string): string {
+  // Remove all non-alphanumeric characters except spaces
+  const cleaned = input.replace(/[^a-zA-Z0-9 ]/g, " ");
+
+  // Split by whitespace, lowercase first word, capitalize others
+  const words = cleaned.trim().split(/\s+/);
+
+  if (words.length === 0) return "";
+
+  let camelCase =
+    words[0].toLowerCase() +
+    words
+      .slice(1)
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+      .join("");
+
+  // Ensure it doesn't start with a digit
+  if (/^[0-9]/.test(camelCase)) {
+    camelCase = "_" + camelCase;
+  }
+
+  return camelCase;
+}
+
+
+export { toCamelCase};

package/src/helper/wrapper/PlaywrightWrappers.ts

@@ -0,0 +1,28 @@
+import { Page } from "@playwright/test";
+
+export default class PlaywrightWrapper {
+
+    constructor(private page: Page) { }
+
+    async goto(url: string) {
+        await this.page.goto(url, {
+            waitUntil: "domcontentloaded"
+        });
+    }
+
+    async waitAndClick(locator: string) {
+        const element = this.page.locator(locator);
+        await element.waitFor({
+            state: "visible"
+        });
+        await element.click();
+    }
+
+    async navigateTo(link: string) {
+        await Promise.all([
+            this.page.waitForNavigation(),
+            this.page.click(link)
+        ])
+    }
+
+}