healenium-js
Version:
Healenium-style self-healing decorator for Playwright in TypeScript
106 lines (105 loc) • 4.79 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Healenium = Healenium;
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const js_levenshtein_1 = __importDefault(require("js-levenshtein"));
const fallbackFile = path_1.default.join(__dirname, 'fallback-selectors.json');
const historyFile = path_1.default.join(__dirname, 'selector-history.json');
function loadFallbacks() {
if (fs_1.default.existsSync(fallbackFile)) {
return JSON.parse(fs_1.default.readFileSync(fallbackFile, 'utf-8'));
}
return {};
}
function saveFallback(original, healed) {
const data = loadFallbacks();
data[original] = healed;
fs_1.default.writeFileSync(fallbackFile, JSON.stringify(data, null, 2));
}
function updateSelectorHistory(original, healed) {
let history = {};
if (fs_1.default.existsSync(historyFile)) {
history = JSON.parse(fs_1.default.readFileSync(historyFile, 'utf-8'));
}
if (!history[original]) {
history[original] = [];
}
if (!history[original].includes(healed)) {
history[original].push(healed);
}
fs_1.default.writeFileSync(historyFile, JSON.stringify(history, null, 2));
}
function findSimilarSelector(page, failedSelector) {
return __awaiter(this, void 0, void 0, function* () {
const failedText = yield page.locator(failedSelector).textContent().catch(() => '');
if (!failedText)
return null;
const elements = yield page.$$('body *');
let bestMatch = { selector: '', score: Infinity };
for (const el of elements) {
const text = yield el.textContent();
if (!text)
continue;
const distance = (0, js_levenshtein_1.default)(failedText.trim(), text.trim());
if (distance < bestMatch.score && distance < 10) {
const tag = yield el.evaluate(el => el.tagName.toLowerCase());
bestMatch = {
selector: `${tag}:has-text("${text.trim()}")`,
score: distance
};
}
}
if (bestMatch.selector) {
saveFallback(failedSelector, bestMatch.selector);
updateSelectorHistory(failedSelector, bestMatch.selector);
return bestMatch.selector;
}
return null;
});
}
function Healenium(failedSelector) {
return function (_target, _propertyKey, descriptor) {
const originalMethod = descriptor.value;
descriptor.value = function (...args) {
return __awaiter(this, void 0, void 0, function* () {
const page = this.page || args.find(arg => typeof arg === 'object' && 'click' in arg);
if (!page)
throw new Error('No Page object found for healing logic');
try {
yield originalMethod.apply(this, args);
}
catch (e) {
console.warn('[Healenium] Attempting to heal from error:', e.message);
const fallbacks = loadFallbacks();
if (fallbacks[failedSelector]) {
console.info(`[Healenium] Retrying with healed selector: ${fallbacks[failedSelector]}`);
yield page.click(fallbacks[failedSelector]);
updateSelectorHistory(failedSelector, fallbacks[failedSelector]);
return;
}
const healedSelector = yield findSimilarSelector(page, failedSelector);
if (healedSelector) {
console.info(`[Healenium] Found and stored healed selector: ${healedSelector}`);
yield page.click(healedSelector);
}
else {
throw e;
}
}
});
};
};
}