@letsrunit/playwright 0.19.0 → 0.19.2

package/dist/index.d.ts

@@ -16,7 +16,7 @@ declare function setFieldValue(el: Locator, value: Value, options?: SetOptions):
 declare function formatHtml(page: string | Page): Promise<string>;
 
 /**
- * Locates an element using Playwright selectors, with lazy fallbacks.
+ * Locates an element using Playwright selectors, with ordered runtime fallbacks.
  */
 declare function fuzzyLocator(page: Page, selector: string): Promise<Locator>;
 

package/dist/index.js

@@ -68746,6 +68746,173 @@ async function formatHtml(page) {
   return String(file);
 }
 
+// src/fallback-locator.ts
+var ACTION_METHODS = /* @__PURE__ */ new Set([
+  "blur",
+  "check",
+  "clear",
+  "click",
+  "dblclick",
+  "dispatchEvent",
+  "dragTo",
+  "fill",
+  "focus",
+  "hover",
+  "press",
+  "pressSequentially",
+  "scrollIntoViewIfNeeded",
+  "selectOption",
+  "setChecked",
+  "setInputFiles",
+  "tap",
+  "type",
+  "uncheck"
+]);
+var LOCATOR_CHAIN_METHODS = /* @__PURE__ */ new Set([
+  "and",
+  "first",
+  "last",
+  "locator",
+  "nth",
+  "or"
+]);
+var NO_WAIT_OPTION_INDEX = {
+  dragTo: 1,
+  fill: 1,
+  press: 1,
+  pressSequentially: 1,
+  selectOption: 1,
+  setInputFiles: 1,
+  type: 1
+};
+function buildOrLocator(candidates) {
+  let result = candidates[0];
+  for (const candidate of candidates.slice(1)) {
+    result = result.or(candidate);
+  }
+  return result;
+}
+async function firstPresentFallback(candidates) {
+  for (const candidate of candidates.slice(1)) {
+    try {
+      if (await candidate.count() > 0) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function withNoWaitTimeout(method, args) {
+  const next = [...args];
+  const optionIndex = NO_WAIT_OPTION_INDEX[method] ?? 0;
+  const current = next[optionIndex];
+  if (current && typeof current === "object") {
+    next[optionIndex] = { ...current, timeout: 0 };
+  } else {
+    next[optionIndex] = { timeout: 0 };
+  }
+  return next;
+}
+function handleExpect(primary, candidates) {
+  return (expression, options) => {
+    if (expression.includes("to.be.visible") || expression.includes("to.be.attached")) {
+      return buildOrLocator(candidates)._expect(expression, options);
+    }
+    return primary._expect(expression, options);
+  };
+}
+function handleAll(candidates) {
+  return async () => {
+    const all = [];
+    for (const candidate of candidates) {
+      all.push(...await candidate.all());
+    }
+    return all;
+  };
+}
+function handleLocatorChain(prop, candidates) {
+  return (...args) => createFallbackLocator(
+    candidates.map((candidate) => {
+      const method = candidate[prop];
+      return method.apply(candidate, args);
+    })
+  );
+}
+function handleCount(primary, candidates) {
+  return async () => {
+    const primaryCount = await primary.count();
+    if (primaryCount > 0) return primaryCount;
+    const fallback = await firstPresentFallback(candidates);
+    if (!fallback) return primaryCount;
+    return fallback.count();
+  };
+}
+function handleAction(prop, primary, candidates, primaryMethod) {
+  return async (...args) => {
+    try {
+      return await primaryMethod.apply(primary, args);
+    } catch (error) {
+      const fallback = await firstPresentFallback(candidates);
+      if (!fallback) throw error;
+      const fallbackMethod = fallback[prop];
+      return fallbackMethod.apply(fallback, withNoWaitTimeout(prop, args));
+    }
+  };
+}
+function handleAsyncFallback(prop, primaryMethod, primary, candidates) {
+  return (...args) => {
+    const result = primaryMethod.apply(primary, args);
+    if (!result || typeof result !== "object" || typeof result.catch !== "function") {
+      return result;
+    }
+    return result.catch(async (error) => {
+      const fallback = await firstPresentFallback(candidates);
+      if (!fallback) throw error;
+      const fallbackMethod = fallback[prop];
+      return fallbackMethod.apply(fallback, args);
+    });
+  };
+}
+function formatLocatorChain(candidates) {
+  const parts = candidates.map((candidate) => candidate.toString());
+  if (parts.length === 0) return "";
+  if (parts.length === 1) return parts[0];
+  return `${parts[0]} {fuzzy}`;
+}
+function createFallbackLocator(candidates) {
+  const primary = candidates[0];
+  const unsupported = /* @__PURE__ */ new Set(["filter", "getByRole", "getByLabel"]);
+  const proxy = new Proxy(primary, {
+    get(_target, prop) {
+      if (typeof prop !== "string") return primary[prop];
+      switch (prop) {
+        case "toString":
+          return () => formatLocatorChain(candidates);
+        case "all":
+          return handleAll(candidates);
+        case "_expect":
+          return handleExpect(primary, candidates);
+        case "count":
+          return handleCount(primary, candidates);
+      }
+      if (unsupported.has(prop)) {
+        return () => {
+          throw new Error(`FallbackLocator does not support ${prop}`);
+        };
+      }
+      if (LOCATOR_CHAIN_METHODS.has(prop)) {
+        return handleLocatorChain(prop, candidates);
+      }
+      const primaryMethod = primary[prop];
+      if (typeof primaryMethod !== "function") return primaryMethod;
+      if (ACTION_METHODS.has(prop)) {
+        return handleAction(prop, primary, candidates, primaryMethod);
+      }
+      return handleAsyncFallback(prop, primaryMethod, primary, candidates);
+    }
+  });
+  return proxy;
+}
+
 // src/fuzzy-locator.ts
 function debug(...args) {
   if (process.env.LETSRUNIT_DEBUG_FUZZY_LOCATOR === "1") {
@@ -68754,6 +68921,11 @@ function debug(...args) {
 }
 async function fuzzyLocator(page, selector) {
   debug("input selector:", selector);
+  const candidates = buildFuzzyCandidates(page, selector);
+  debug("enabled fallbacks:", candidates.length > 1 ? String(candidates.length - 1) : "(none)");
+  return createFallbackLocator(candidates);
+}
+function buildFuzzyCandidates(page, selector) {
   const primary = page.locator(selector);
   const candidates = [
     { name: "relaxNameToHasText", locator: tryRelaxNameToHasText(page, selector) },
@@ -68762,17 +68934,13 @@ async function fuzzyLocator(page, selector) {
     { name: "fieldAlternative", locator: tryFieldAlternative(page, selector) },
     { name: "asField", locator: tryAsField(page, selector) }
   ];
-  let combined = primary;
-  const enabled = [];
+  const all = [primary];
   for (const candidate of candidates) {
     if (!candidate.locator) continue;
-    enabled.push(candidate.name);
-    combined = combined.or(candidate.locator);
+    debug("enabling fallback:", candidate.name, candidate.locator.toString());
+    all.push(candidate.locator);
   }
-  debug("enabled fallbacks:", enabled.length ? enabled.join(", ") : "(none)");
-  const result = combined.first();
-  debug("returning locator:", result.toString());
-  return result;
+  return all;
 }
 function tryRelaxNameToHasText(page, selector) {
   const matchAnyNameFull = selector.match(/^(role=.*)\[name="([^"]+)"i?](.*)$/i);
@@ -68793,7 +68961,7 @@ function tryRoleNameProximity(page, selector) {
   const matchRole = selector.match(/^role=(\w+)\s*\[name="([^"]+)"i?](.*)$/i);
   if (!matchRole) return null;
   const [, role, name, rest] = matchRole;
-  const proximitySelector = `text=${name} >> .. >> role=${role}${rest}`;
+  const proximitySelector = `text=${name} >> xpath=following-sibling::* >> role=${role}${rest}`;
   return page.locator(proximitySelector);
 }
 function tryFieldAlternative(page, selector) {