playwright-advanced-ml-healer/dist/utils.js

Advanced AI-powered self-healing selectors for Playwright with 19+ healing types, neural networks, machine learning models, and Global DOM Learning ML Model

"use strict";
/**
 * Utility functions for Advanced ML Healing System
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.calculateStringSimilarity = calculateStringSimilarity;
exports.calculateLevenshteinDistance = calculateLevenshteinDistance;
exports.calculateCosineSimilarity = calculateCosineSimilarity;
exports.areAnagrams = areAnagrams;
exports.normalizeString = normalizeString;
exports.extractCommonPatterns = extractCommonPatterns;
/**
 * Calculate string similarity using various algorithms
 */
function calculateStringSimilarity(str1, str2) {
    if (str1 === str2)
        return 1.0;
    if (str1.length === 0 || str2.length === 0)
        return 0.0;
    const distance = calculateLevenshteinDistance(str1, str2);
    const maxLength = Math.max(str1.length, str2.length);
    return 1 - (distance / maxLength);
}
/**
 * Calculate Levenshtein distance between two strings
 */
function calculateLevenshteinDistance(str1, str2) {
    const matrix = Array(str2.length + 1).fill(null).map(() => Array(str1.length + 1).fill(null));
    for (let i = 0; i <= str1.length; i++) {
        matrix[0][i] = i;
    }
    for (let j = 0; j <= str2.length; j++) {
        matrix[j][0] = j;
    }
    for (let j = 1; j <= str2.length; j++) {
        for (let i = 1; i <= str1.length; i++) {
            const indicator = str1[i - 1] === str2[j - 1] ? 0 : 1;
            matrix[j][i] = Math.min(matrix[j][i - 1] + 1, // deletion
            matrix[j - 1][i] + 1, // insertion
            matrix[j - 1][i - 1] + indicator // substitution
            );
        }
    }
    return matrix[str2.length][str1.length];
}
/**
 * Calculate cosine similarity between two strings
 */
function calculateCosineSimilarity(str1, str2) {
    const words1 = str1.toLowerCase().split(/\s+/);
    const words2 = str2.toLowerCase().split(/\s+/);
    const wordCount1 = new Map();
    const wordCount2 = new Map();
    words1.forEach(word => {
        wordCount1.set(word, (wordCount1.get(word) || 0) + 1);
    });
    words2.forEach(word => {
        wordCount2.set(word, (wordCount2.get(word) || 0) + 1);
    });
    const allWords = new Set([...wordCount1.keys(), ...wordCount2.keys()]);
    let dotProduct = 0;
    let norm1 = 0;
    let norm2 = 0;
    allWords.forEach(word => {
        const count1 = wordCount1.get(word) || 0;
        const count2 = wordCount2.get(word) || 0;
        dotProduct += count1 * count2;
        norm1 += count1 * count1;
        norm2 += count2 * count2;
    });
    if (norm1 === 0 || norm2 === 0)
        return 0;
    return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
}
/**
 * Check if two strings are anagrams
 */
function areAnagrams(str1, str2) {
    if (str1.length !== str2.length)
        return false;
    const charCount = new Map();
    for (const char of str1.toLowerCase()) {
        charCount.set(char, (charCount.get(char) || 0) + 1);
    }
    for (const char of str2.toLowerCase()) {
        const count = charCount.get(char);
        if (!count)
            return false;
        charCount.set(char, count - 1);
    }
    return true;
}
/**
 * Normalize string for comparison
 */
function normalizeString(str) {
    return str
        .toLowerCase()
        .replace(/[^a-z0-9]/g, '')
        .trim();
}
/**
 * Extract common patterns from strings
 */
function extractCommonPatterns(str1, str2) {
    const patterns = [];
    const minLength = 3;
    for (let len = minLength; len <= Math.min(str1.length, str2.length); len++) {
        for (let i = 0; i <= str1.length - len; i++) {
            const pattern = str1.substring(i, i + len);
            if (str2.includes(pattern)) {
                patterns.push(pattern);
            }
        }
    }
    return [...new Set(patterns)].sort((a, b) => b.length - a.length);
}
//# sourceMappingURL=utils.js.map