@pwtap/create 0.1.0

package/template/utils/stringUtils.ts

@@ -0,0 +1,192 @@
+/**
+ * String Utility Functions
+ * Provides string manipulation and formatting helpers
+ */
+
+export class StringUtils {
+  /**
+   * Generate random string
+   */
+  static generateRandomString(length: number = 10): string {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+  }
+
+  /**
+   * Generate random alphanumeric string
+   */
+  static generateRandomAlphanumeric(length: number = 10): string {
+    return this.generateRandomString(length);
+  }
+
+  /**
+   * Generate random numeric string
+   */
+  static generateRandomNumeric(length: number = 10): string {
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += Math.floor(Math.random() * 10);
+    }
+    return result;
+  }
+
+  /**
+   * Generate random email
+   */
+  static generateRandomEmail(domain: string = 'example.com'): string {
+    const username = this.generateRandomString(10).toLowerCase();
+    return `${username}@${domain}`;
+  }
+
+  /**
+   * Generate a timestamp-based email, unique per run.
+   *
+   * @param prefix - Username prefix (default: 'test_user')
+   * @param domain - Email domain (default: 'example.com')
+   * @param digits - Number of trailing timestamp digits to append (default: 4)
+   * @returns Email like "test_user_5821@example.com"
+   */
+  static generateTimestampEmail(
+    prefix: string = 'test_user',
+    domain: string = 'example.com',
+    digits: number = 4,
+  ): string {
+    const timestamp = Date.now().toString();
+    const suffix = timestamp.slice(-digits);
+    return `${prefix}_${suffix}@${domain}`;
+  }
+
+  /**
+   * Generate random phone number
+   * @param countryCode - Country code (default: '+1')
+   * @param prefix - Phone number prefix (default: '555')
+   * @param length - Number of random digits after prefix (default: 7)
+   * @returns Phone number in format like "+1 5551234567"
+   */
+  static generateRandomPhoneNumber(
+    countryCode: string = '+1',
+    prefix: string = '555',
+    length: number = 7,
+  ): string {
+    const randomDigits = this.generateRandomNumeric(length);
+    return `${countryCode} ${prefix}${randomDigits}`;
+  }
+
+  /**
+   * Generate UUID v4
+   */
+  static generateUUID(): string {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+      const r = (Math.random() * 16) | 0;
+      const v = c === 'x' ? r : (r & 0x3) | 0x8;
+      return v.toString(16);
+    });
+  }
+
+  /**
+   * Capitalize first letter
+   */
+  static capitalize(str: string): string {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+
+  /**
+   * Convert to title case
+   */
+  static toTitleCase(str: string): string {
+    return str
+      .toLowerCase()
+      .split(' ')
+      .map(word => this.capitalize(word))
+      .join(' ');
+  }
+
+  /**
+   * Convert to camelCase
+   */
+  static toCamelCase(str: string): string {
+    return str
+      .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) =>
+        index === 0 ? word.toLowerCase() : word.toUpperCase(),
+      )
+      .replace(/\s+/g, '');
+  }
+
+  /**
+   * Convert to snake_case
+   */
+  static toSnakeCase(str: string): string {
+    return str
+      .replace(/\W+/g, ' ')
+      .split(/ |\B(?=[A-Z])/)
+      .map(word => word.toLowerCase())
+      .join('_');
+  }
+
+  /**
+   * Convert to kebab-case
+   */
+  static toKebabCase(str: string): string {
+    return str
+      .replace(/\W+/g, ' ')
+      .split(/ |\B(?=[A-Z])/)
+      .map(word => word.toLowerCase())
+      .join('-');
+  }
+
+  /**
+   * Truncate string to specified length
+   */
+  static truncate(str: string, length: number, suffix: string = '...'): string {
+    if (str.length <= length) return str;
+    return str.slice(0, length - suffix.length) + suffix;
+  }
+
+  /**
+   * Check if string is empty or whitespace
+   */
+  static isBlank(str: string | null | undefined): boolean {
+    return !str || str.trim().length === 0;
+  }
+
+  /**
+   * Remove extra whitespace
+   */
+  static normalizeWhitespace(str: string): string {
+    return str.trim().replace(/\s+/g, ' ');
+  }
+
+  /**
+   * Escape HTML special characters
+   */
+  static escapeHtml(str: string): string {
+    const htmlEntities: Record<string, string> = {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#39;',
+    };
+    return str.replace(/[&<>"']/g, char => htmlEntities[char]);
+  }
+
+  /**
+   * Extract numbers from string
+   */
+  static extractNumbers(str: string): string {
+    return str.replace(/\D/g, '');
+  }
+
+  /**
+   * Mask string (e.g., for sensitive data)
+   */
+  static mask(str: string, visibleChars: number = 4, maskChar: string = '*'): string {
+    if (str.length <= visibleChars) return str;
+    const masked = maskChar.repeat(str.length - visibleChars);
+    return masked + str.slice(-visibleChars);
+  }
+}

package/template/utils/uiUtils.ts

@@ -0,0 +1,236 @@
+import type { Locator, Page } from '@playwright/test';
+
+/**
+ * UI Utility Functions for Playwright Tests
+ * Provides common UI interaction helpers
+ */
+
+export class UIUtils {
+  /**
+   * Scroll to element and make it visible
+   */
+  static async scrollToElement(element: Locator): Promise<void> {
+    await element.scrollIntoViewIfNeeded();
+  }
+
+  static async clickButton(page: Page, button: string): Promise<void> {
+    await page.getByRole('button', { name: button }).first().click();
+  }
+
+  /**
+   * Click element with retry logic
+   */
+  static async clickWithRetry(
+    element: Locator,
+    maxRetries: number = 3,
+    delay: number = 1000,
+  ): Promise<void> {
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        await element.click({ timeout: 5000 });
+        return;
+      } catch (error) {
+        if (i === maxRetries - 1) throw error;
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  /**
+   * Force click on element (useful for hidden or overlapped elements)
+   */
+  static async forceClick(element: Locator): Promise<void> {
+    await element.click({ force: true });
+  }
+
+  /**
+   * Double click on element
+   */
+  static async doubleClick(element: Locator): Promise<void> {
+    await element.dblclick();
+  }
+
+  /**
+   * Right click on element
+   */
+  static async rightClick(element: Locator): Promise<void> {
+    await element.click({ button: 'right' });
+  }
+
+  /**
+   * Hover over element
+   */
+  static async hover(element: Locator): Promise<void> {
+    await element.hover();
+  }
+
+  /**
+   * Fill input with clearing first
+   */
+  static async fillInput(element: Locator, text: string): Promise<void> {
+    await element.clear();
+    await element.fill(text);
+  }
+
+  /**
+   * Type text slowly (character by character)
+   */
+  static async typeSlowly(element: Locator, text: string, delay: number = 100): Promise<void> {
+    await element.click();
+    await element.pressSequentially(text, { delay });
+  }
+
+  /**
+   * Select option from dropdown by value
+   */
+  static async selectDropdownByValue(element: Locator, value: string): Promise<void> {
+    await element.selectOption({ value });
+  }
+
+  /**
+   * Select option from dropdown by label
+   */
+  static async selectDropdownByLabel(element: Locator, label: string): Promise<void> {
+    await element.selectOption({ label });
+  }
+
+  /**
+   * Select option from dropdown by index
+   */
+  static async selectDropdownByIndex(element: Locator, index: number): Promise<void> {
+    await element.selectOption({ index });
+  }
+
+  /**
+   * Check checkbox
+   */
+  static async checkCheckbox(element: Locator): Promise<void> {
+    await element.check();
+  }
+
+  /**
+   * Uncheck checkbox
+   */
+  static async uncheckCheckbox(element: Locator): Promise<void> {
+    await element.uncheck();
+  }
+
+  /**
+   * Toggle checkbox
+   */
+  static async toggleCheckbox(element: Locator): Promise<void> {
+    const isChecked = await element.isChecked();
+    if (isChecked) {
+      await element.uncheck();
+    } else {
+      await element.check();
+    }
+  }
+
+  /**
+   * Get element text content
+   */
+  static async getText(element: Locator): Promise<string> {
+    return (await element.textContent()) || '';
+  }
+
+  /**
+   * Get element input value
+   */
+  static async getValue(element: Locator): Promise<string> {
+    return await element.inputValue();
+  }
+
+  /**
+   * Check if element is visible
+   */
+  static async isVisible(element: Locator): Promise<boolean> {
+    return await element.isVisible();
+  }
+
+  /**
+   * Check if element is enabled
+   */
+  static async isEnabled(element: Locator): Promise<boolean> {
+    return await element.isEnabled();
+  }
+
+  /**
+   * Check if element exists in DOM
+   */
+  static async exists(element: Locator): Promise<boolean> {
+    return (await element.count()) > 0;
+  }
+
+  /**
+   * Upload file to input
+   */
+  static async uploadFile(element: Locator, filePath: string | string[]): Promise<void> {
+    await element.setInputFiles(filePath);
+  }
+
+  /**
+   * Clear file input
+   */
+  static async clearFileInput(element: Locator): Promise<void> {
+    await element.setInputFiles([]);
+  }
+
+  /**
+   * Get attribute value
+   */
+  static async getAttribute(element: Locator, name: string): Promise<string | null> {
+    return await element.getAttribute(name);
+  }
+
+  /**
+   * Focus element
+   */
+  static async focus(element: Locator): Promise<void> {
+    await element.focus();
+  }
+
+  /**
+   * Blur element
+   */
+  static async blur(element: Locator): Promise<void> {
+    await element.blur();
+  }
+
+  /**
+   * Press keyboard key on element
+   */
+  static async pressKey(element: Locator, key: string): Promise<void> {
+    await element.press(key);
+  }
+
+  /**
+   * Drag and drop element
+   */
+  static async dragAndDrop(source: Locator, target: Locator): Promise<void> {
+    await source.dragTo(target);
+  }
+
+  /**
+   * Take screenshot of element
+   */
+  static async screenshot(element: Locator, path: string): Promise<Buffer> {
+    return await element.screenshot({ path });
+  }
+
+  /**
+   * Wait for element animation to complete
+   */
+  static async waitForAnimation(element: Locator, timeout: number = 1000): Promise<void> {
+    await element.evaluate((el, t) => {
+      return new Promise<void>(resolve => {
+        const animations = el.getAnimations();
+        if (animations.length === 0) {
+          setTimeout(resolve, t);
+        } else {
+          Promise.all(animations.map(a => a.finished)).then(() => resolve());
+        }
+      });
+    }, timeout);
+  }
+}

package/template/utils/validationUtils.ts

@@ -0,0 +1,190 @@
+/**
+ * Validation Utility Functions
+ * Provides data validation helpers
+ */
+
+export class ValidationUtils {
+  /**
+   * Validate email format
+   */
+  static isValidEmail(email: string): boolean {
+    const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+    return emailRegex.test(email);
+  }
+
+  /**
+   * Validate password strength
+   */
+  static isStrongPassword(
+    password: string,
+    options?: {
+      minLength?: number;
+      requireUppercase?: boolean;
+      requireLowercase?: boolean;
+      requireNumbers?: boolean;
+      requireSpecialChars?: boolean;
+    },
+  ): { valid: boolean; errors: string[] } {
+    const {
+      minLength = 8,
+      requireUppercase = true,
+      requireLowercase = true,
+      requireNumbers = true,
+      requireSpecialChars = true,
+    } = options || {};
+
+    const errors: string[] = [];
+
+    if (password.length < minLength) {
+      errors.push(`Password must be at least ${minLength} characters long`);
+    }
+
+    if (requireUppercase && !/[A-Z]/.test(password)) {
+      errors.push('Password must contain at least one uppercase letter');
+    }
+
+    if (requireLowercase && !/[a-z]/.test(password)) {
+      errors.push('Password must contain at least one lowercase letter');
+    }
+
+    if (requireNumbers && !/\d/.test(password)) {
+      errors.push('Password must contain at least one number');
+    }
+
+    if (requireSpecialChars && !/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
+      errors.push('Password must contain at least one special character');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+    };
+  }
+
+  /**
+   * Validate phone number
+   */
+  static isValidPhoneNumber(phone: string, countryCode?: string): boolean {
+    // Remove all non-numeric characters
+    const cleaned = phone.replace(/\D/g, '');
+
+    // Basic validation (10-15 digits)
+    if (cleaned.length < 10 || cleaned.length > 15) {
+      return false;
+    }
+
+    // Country-specific validation
+    if (countryCode === 'US') {
+      return /^1?\d{10}$/.test(cleaned);
+    }
+
+    return true;
+  }
+
+  /**
+   * Validate URL format
+   */
+  static isValidURL(url: string): boolean {
+    try {
+      const urlObj = new URL(url);
+      return ['http:', 'https:'].includes(urlObj.protocol);
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Validate credit card number (Luhn algorithm)
+   */
+  static isValidCreditCard(cardNumber: string): boolean {
+    const cleaned = cardNumber.replace(/\D/g, '');
+
+    if (cleaned.length < 13 || cleaned.length > 19) {
+      return false;
+    }
+
+    let sum = 0;
+    let isEven = false;
+
+    for (let i = cleaned.length - 1; i >= 0; i--) {
+      let digit = parseInt(cleaned[i], 10);
+
+      if (isEven) {
+        digit *= 2;
+        if (digit > 9) {
+          digit -= 9;
+        }
+      }
+
+      sum += digit;
+      isEven = !isEven;
+    }
+
+    return sum % 10 === 0;
+  }
+
+  /**
+   * Validate date string
+   */
+  static isValidDate(dateString: string): boolean {
+    const date = new Date(dateString);
+    return !isNaN(date.getTime());
+  }
+
+  /**
+   * Validate JSON string
+   */
+  static isValidJSON(str: string): boolean {
+    try {
+      JSON.parse(str);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Validate UUID format
+   */
+  static isValidUUID(uuid: string): boolean {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(uuid);
+  }
+
+  /**
+   * Validate IP address (v4)
+   */
+  static isValidIPv4(ip: string): boolean {
+    const ipv4Regex =
+      /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+    return ipv4Regex.test(ip);
+  }
+
+  /**
+   * Check if value is within range
+   */
+  static isInRange(value: number, min: number, max: number): boolean {
+    return value >= min && value <= max;
+  }
+
+  /**
+   * Check if string matches pattern
+   */
+  static matchesPattern(str: string, pattern: RegExp): boolean {
+    return pattern.test(str);
+  }
+
+  /**
+   * Validate array is not empty
+   */
+  static isNonEmptyArray(arr: unknown): boolean {
+    return Array.isArray(arr) && arr.length > 0;
+  }
+
+  /**
+   * Validate object has required properties
+   */
+  static hasRequiredProperties(obj: Record<string, unknown>, requiredProps: string[]): boolean {
+    return requiredProps.every(prop => prop in obj && obj[prop] !== undefined);
+  }
+}