sela-core 1.0.0

package/dist/fixtures/expectProxy.js

@@ -0,0 +1,228 @@
+"use strict";
+// src/fixtures/expectProxy.ts — full replacement
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHealingExpect = createHealingExpect;
+const test_1 = require("@playwright/test");
+const HealingRegistry_1 = require("../engine/HealingRegistry");
+const ELEMENT_NOT_FOUND_PATTERNS = [
+    /element.*not found/i,
+    /locator.*resolved to.*\d+ element/i,
+    /waiting for.*locator/i,
+    /timeout.*exceeded/i,
+];
+function isElementNotFoundError(err) {
+    if (!(err instanceof Error))
+        return false;
+    return ELEMENT_NOT_FOUND_PATTERNS.some((p) => p.test(err.message));
+}
+/**
+ * Returns true only for genuine Playwright Locator instances —
+ * not FrameLocator proxies or Fixwright proxy objects.
+ *
+ * A real Locator has _frame internally.
+ * A FrameLocator has _frameSelector instead.
+ * We must NOT intercept frame-scoped locators because we cannot
+ * safely rebuild them from a bare selector string on page.locator().
+ */
+function isRealLocator(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (typeof value !== "object")
+        return false;
+    const hasFrame = value._frame !== undefined ||
+        value._impl?._frame !== undefined;
+    const isFrameLocator = value._frameSelector !== undefined ||
+        value._impl?._frameSelector !== undefined;
+    return hasFrame && !isFrameLocator;
+}
+/**
+ * Detect whether a locator is frame-scoped by checking its internal
+ * selector string for frame-related segments.
+ */
+function isFrameScopedLocator(locator) {
+    const sel = locator._selector ?? locator["_impl"]?._selector ?? "";
+    return (typeof sel === "string" &&
+        (sel.includes("internal:control=enter-frame") ||
+            sel.includes(">> internal:control=enter-frame")));
+}
+/**
+ * Extracts the internal Playwright selector string from a real Locator.
+ */
+function extractSelectorFromLocator(locator) {
+    const internal = locator._selector ?? locator["_impl"]?._selector;
+    return typeof internal === "string" ? internal : null;
+}
+/**
+ * Rebuild a locator from a healed selector string that may contain
+ * frame segments (e.g. "#modern-frame-container >> #status-label-v2").
+ *
+ * A plain page.locator() call with a frame >> element string is NOT
+ * a valid locator for frame content — Playwright rejects it with
+ * "toHaveText can be only used with Locator object".
+ *
+ * This function correctly chains frameLocator() calls for each frame
+ * segment, then calls .locator() for the final element segment.
+ *
+ * Convention used by FixwrightEngine segments:
+ *   - Frame segments look like CSS selectors for iframes (#id, .class)
+ *     but produce a FrameLocator, not a Locator.
+ *   - The last segment is always the element selector.
+ *   - "internal:control=enter-frame" segments are implicit in
+ *     Playwright's FrameLocator and should be skipped.
+ *
+ * Examples:
+ *   "#modern-frame-container >> #status-label-v2"
+ *   → page.frameLocator("#modern-frame-container").locator("#status-label-v2")
+ *
+ *   "#outer >> #inner-frame >> .button"
+ *   → page.frameLocator("#outer").frameLocator("#inner-frame").locator(".button")
+ *
+ *   "#simple-element"
+ *   → page.locator("#simple-element")
+ */
+function rebuildLocator(page, healedSelector) {
+    // --- הוספת השורה הזו ---
+    // מוודא שאנחנו עובדים עם האובייקט האמיתי של פליירייט ולא עם הפרוקסי שלנו
+    const rawPage = page._rawPage || page;
+    const segments = healedSelector
+        .split(" >> ")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0 && s !== "internal:control=enter-frame");
+    if (segments.length === 0)
+        return rawPage.locator(healedSelector);
+    if (segments.length === 1)
+        return rawPage.locator(segments[0]);
+    const frameSegments = segments.slice(0, segments.length - 1);
+    const elementSegment = segments[segments.length - 1];
+    let context = null;
+    for (const frameSel of frameSegments) {
+        if (context === null) {
+            context = rawPage.frameLocator(frameSel);
+        }
+        else {
+            context = context.frameLocator(frameSel);
+        }
+    }
+    // כאן אנחנו מחזירים לוקטור שנוצר ישירות מה-rawPage
+    return context.locator(elementSegment);
+}
+/**
+ * Wrap a single matcher so that element-not-found errors trigger the
+ * heal cycle and retry the assertion once on the correctly rebuilt locator.
+ */
+function wrapMatcher(matcher, locator, matcherName, engine, page, ctx) {
+    return (async (...args) => {
+        try {
+            return await matcher(...args);
+        }
+        catch (err) {
+            if (!isElementNotFoundError(err))
+                throw err;
+            const rawSelector = extractSelectorFromLocator(locator);
+            if (!rawSelector)
+                throw err;
+            console.log(`[Fixwright-Expect] ⚠️ Assertion failed for "${rawSelector}", attempting heal…`);
+            // Fast path — already healed in this test via registry
+            const resolved = HealingRegistry_1.HealingRegistry.getInstance().resolveSelector(rawSelector, ctx);
+            let healedSelector = resolved;
+            if (resolved === rawSelector) {
+                // Slow path — ask the engine + LLM.
+                // engine.heal() writes the fix to disk AND returns the canonical
+                // healedLocatorString from SourceUpdater — the exact same string
+                // that was saved to the file.  This is the handshake that guarantees
+                // disk and runtime are in sync (no "ghost failures").
+                const stableId = require("crypto")
+                    .createHash("md5")
+                    .update(rawSelector)
+                    .digest("hex");
+                try {
+                    healedSelector = await engine.heal(page, rawSelector, rawSelector, stableId, ctx.filePath, ctx.line, "assertion");
+                }
+                catch (healErr) {
+                    if (healErr instanceof Error &&
+                        healErr.message.includes("[SafetyGuard]")) {
+                        throw healErr;
+                    }
+                    throw err;
+                }
+            }
+            if (!healedSelector || healedSelector === rawSelector)
+                throw err;
+            // Rebuild the locator from the canonical selector returned by the
+            // updater.  rebuildLocator() correctly chains frameLocator() calls
+            // for each frame segment, then .locator() for the final element,
+            // ensuring page/frame/locator variables are scoped correctly at runtime.
+            const newLocator = rebuildLocator(page, healedSelector);
+            const newExpectation = (0, test_1.expect)(newLocator);
+            const retryMatcher = newExpectation[matcherName];
+            if (typeof retryMatcher !== "function")
+                throw err;
+            console.log(`[Fixwright-Expect] ♻️  Retrying assertion with healed selector: "${healedSelector}"`);
+            return await retryMatcher.apply(newExpectation, args);
+        }
+    });
+}
+const WRAPPED_MATCHERS = [
+    "toBeVisible",
+    "toBeHidden",
+    "toBeEnabled",
+    "toBeDisabled",
+    "toHaveText",
+    "toContainText",
+    "toHaveValue",
+    "toHaveAttribute",
+    "toHaveCount",
+    "toBeChecked",
+    "toBeFocused",
+];
+/**
+ * createHealingExpect — drop-in replacement for Playwright's expect().
+ *
+ * @param resolveProxy  Optional callback that unwraps a Fixwright proxy
+ * to its current live Locator. Supplied by
+ * fixtures/index.ts which owns proxyToActiveLocator.
+ */
+function createHealingExpect(engine, page, filePath, initialLine, // השורה מהפיקסצ'ר (לרוב תהיה לא מדויקת או 0)
+resolveProxy) {
+    return function expect(locatorOrValue) {
+        // 1. חילוץ דינמי של שורת הקוד האמיתית בזמן קריאת ה-expect
+        const getCallerLine = () => {
+            const err = new Error();
+            const stack = err.stack?.split("\n") || [];
+            // מחפשים את הקריאה הראשונה בשרשרת שמגיעה מקובץ הטסט ולא מקובץ הפרוקסי
+            const specLine = stack.find((l) => l.includes(filePath) && !l.includes("expectProxy"));
+            if (specLine) {
+                const match = specLine.match(/:(\d+):(\d+)/);
+                return match ? parseInt(match[1], 10) : initialLine;
+            }
+            return initialLine;
+        };
+        const actualLine = getCallerLine(); // כאן אנחנו מקבלים את השורה הנכונה!
+        // Step 1 — unwrap Fixwright proxy to real active Locator
+        let resolved = locatorOrValue;
+        if (resolveProxy) {
+            const unwrapped = resolveProxy(locatorOrValue);
+            if (unwrapped)
+                resolved = unwrapped;
+        }
+        const base = (0, test_1.expect)(resolved);
+        // Step 2 — only wrap matchers for genuine page-level Locator objects.
+        if (!isRealLocator(resolved)) {
+            return base;
+        }
+        const locator = resolved;
+        // משתמשים בשורה האמיתית שחילצנו עבור ה-Context שמועבר ל-Engine
+        const ctx = { filePath, line: actualLine };
+        const proxy = new Proxy(base, {
+            get(target, prop) {
+                const val = target[prop];
+                if (typeof val === "function" &&
+                    WRAPPED_MATCHERS.includes(prop)) {
+                    return wrapMatcher(val.bind(target), locator, prop, engine, page, ctx);
+                }
+                return val;
+            },
+        });
+        return proxy;
+    };
+}

package/dist/fixtures/index.d.ts

@@ -0,0 +1,6 @@
+import { createHealingExpect } from "./expectProxy";
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & {
+    expect: ReturnType<typeof createHealingExpect>;
+}, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+export { createHealingExpect } from "./expectProxy";
+//# sourceMappingURL=index.d.ts.map

package/dist/fixtures/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fixtures/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAk2BpD,eAAO,MAAM,IAAI;YACP,UAAU,CAAC,OAAO,mBAAmB,CAAC;wGA+F9C,CAAC;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC"}