playwright-core 1.54.0-alpha-2025-06-24 → 1.54.0-alpha-2025-06-25

package/lib/protocol/validator.js

@@ -1657,6 +1657,12 @@ import_validatorPrimitives.scheme.FrameFrameElementParams = (0, import_validator
 import_validatorPrimitives.scheme.FrameFrameElementResult = (0, import_validatorPrimitives.tObject)({
   element: (0, import_validatorPrimitives.tChannel)(["ElementHandle"])
 });
+import_validatorPrimitives.scheme.FrameGenerateLocatorStringParams = (0, import_validatorPrimitives.tObject)({
+  selector: import_validatorPrimitives.tString
+});
+import_validatorPrimitives.scheme.FrameGenerateLocatorStringResult = (0, import_validatorPrimitives.tObject)({
+  value: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString)
+});
 import_validatorPrimitives.scheme.FrameHighlightParams = (0, import_validatorPrimitives.tObject)({
   selector: import_validatorPrimitives.tString
 });
@@ -2050,10 +2056,6 @@ import_validatorPrimitives.scheme.ElementHandleFillParams = (0, import_validator
 import_validatorPrimitives.scheme.ElementHandleFillResult = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
 import_validatorPrimitives.scheme.ElementHandleFocusParams = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
 import_validatorPrimitives.scheme.ElementHandleFocusResult = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
-import_validatorPrimitives.scheme.ElementHandleGenerateLocatorStringParams = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
-import_validatorPrimitives.scheme.ElementHandleGenerateLocatorStringResult = (0, import_validatorPrimitives.tObject)({
-  value: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString)
-});
 import_validatorPrimitives.scheme.ElementHandleGetAttributeParams = (0, import_validatorPrimitives.tObject)({
   name: import_validatorPrimitives.tString
 });

package/lib/server/dispatchers/elementHandlerDispatcher.js

@@ -55,9 +55,6 @@ class ElementHandleDispatcher extends import_jsHandleDispatcher.JSHandleDispatch
     const frame = await this._elementHandle.contentFrame();
     return { frame: frame ? import_frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : void 0 };
   }
-  async generateLocatorString(params, metadata) {
-    return { value: await this._elementHandle.generateLocatorString() };
-  }
   async getAttribute(params, metadata) {
     const value = await this._elementHandle.getAttribute(metadata, params.name);
     return { value: value === null ? void 0 : value };

package/lib/server/dispatchers/frameDispatcher.js

@@ -144,6 +144,9 @@ class FrameDispatcher extends import_dispatcher.Dispatcher {
   async innerHTML(params, metadata) {
     return { value: await this._frame.innerHTML(metadata, params.selector, params) };
   }
+  async generateLocatorString(params, metadata) {
+    return { value: await this._frame.generateLocatorString(metadata, params.selector) };
+  }
   async getAttribute(params, metadata) {
     const value = await this._frame.getAttribute(metadata, params.selector, params.name, params);
     return { value: value === null ? void 0 : value };

package/lib/server/dom.js

@@ -161,35 +161,6 @@ class ElementHandle extends js.JSHandle {
       return null;
     return this._page.delegate.getContentFrame(this);
   }
-  async generateLocatorString() {
-    const selectors = await this._generateSelectorString();
-    if (!selectors.length)
-      return;
-    return (0, import_utils.asLocator)("javascript", selectors.reverse().join(" >> internal:control=enter-frame >> "));
-  }
-  async _generateSelectorString() {
-    const selector = await this.evaluateInUtility(async ([injected, node]) => {
-      return injected.generateSelectorSimple(node);
-    }, {});
-    if (selector === "error:notconnected")
-      return [];
-    let frame = this._frame;
-    const result = [selector];
-    while (frame?.parentFrame()) {
-      const frameElement = await frame.frameElement();
-      if (frameElement) {
-        const selector2 = await frameElement.evaluateInUtility(async ([injected, node]) => {
-          return injected.generateSelectorSimple(node);
-        }, {});
-        frameElement.dispose();
-        if (selector2 === "error:notconnected")
-          return [];
-        result.push(selector2);
-      }
-      frame = frame.parentFrame();
-    }
-    return result;
-  }
   async getAttribute(metadata, name) {
     return this._frame.getAttribute(metadata, ":scope", name, { timeout: 0 }, this);
   }
@@ -321,6 +292,10 @@ class ElementHandle extends js.JSHandle {
         progress.log("  did not find some options");
         continue;
       }
+      if (result === "error:optionnotenabled") {
+        progress.log("  option being selected is not enabled");
+        continue;
+      }
       if (typeof result === "object" && "hitTargetDescription" in result) {
         progress.log(`  ${result.hitTargetDescription} intercepts pointer events`);
         continue;

package/lib/server/frames.js

@@ -1015,6 +1015,35 @@ class Frame extends import_instrumentation.SdkObject {
       dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._blur(progress)));
     }, options.timeout);
   }
+  async generateLocatorString(metadata, selector) {
+    const controller = new import_progress.ProgressController(metadata, this);
+    return controller.run(async (progress) => {
+      const element = await progress.race(this.selectors.query(selector));
+      if (!element)
+        throw new Error(`No element matching ${this._asLocator(selector)}`);
+      const generated = await progress.race(element.evaluateInUtility(async ([injected, node]) => {
+        return injected.generateSelectorSimple(node);
+      }, {}));
+      if (!generated)
+        throw new Error(`Unable to generate locator for ${this._asLocator(selector)}`);
+      let frame = element._frame;
+      const result = [generated];
+      while (frame?.parentFrame()) {
+        const frameElement = await progress.race(frame.frameElement());
+        if (frameElement) {
+          const generated2 = await progress.race(frameElement.evaluateInUtility(async ([injected, node]) => {
+            return injected.generateSelectorSimple(node);
+          }, {}));
+          frameElement.dispose();
+          if (generated2 === "error:notconnected" || !generated2)
+            throw new Error(`Unable to generate locator for ${this._asLocator(selector)}`);
+          result.push(generated2);
+        }
+        frame = frame.parentFrame();
+      }
+      return (0, import_utils.asLocator)(this._page.browserContext._browser.sdkLanguage(), result.reverse().join(" >> internal:control=enter-frame >> "));
+    });
+  }
   async textContent(metadata, selector, options, scope) {
     return this._callOnElementOnceMatches(metadata, selector, (injected, element) => element.textContent, void 0, options, scope);
   }
@@ -1162,43 +1191,32 @@ class Frame extends import_instrumentation.SdkObject {
     return result;
   }
   async _expectImpl(metadata, selector, options) {
+    const controller = new import_progress.ProgressController(metadata, this);
     const lastIntermediateResult = { isSet: false };
-    try {
-      let timeout = options.timeout;
-      const start = timeout > 0 ? (0, import_utils.monotonicTime)() : 0;
-      await new import_progress.ProgressController(metadata, this).run(async (progress) => {
-        progress.log(`${(0, import_utils.renderTitleForCall)(metadata)}${timeout ? ` with timeout ${timeout}ms` : ""}`);
-        if (selector)
-          progress.log(`waiting for ${this._asLocator(selector)}`);
-        await this._page.performActionPreChecks(progress);
-      }, timeout);
+    return await controller.run(async (progress) => {
+      progress.log(`${(0, import_utils.renderTitleForCall)(metadata)}${options.timeout ? ` with timeout ${options.timeout}ms` : ""}`);
+      if (selector)
+        progress.log(`waiting for ${this._asLocator(selector)}`);
+      await this._page.performActionPreChecks(progress);
+      progress.legacyDisableTimeout();
       try {
-        const resultOneShot = await new import_progress.ProgressController(metadata, this).run(async (progress) => {
-          return await this._expectInternal(progress, selector, options, lastIntermediateResult);
-        });
+        const resultOneShot = await this._expectInternal(progress, selector, options, lastIntermediateResult, true);
         if (resultOneShot.matches !== options.isNot)
           return resultOneShot;
       } catch (e) {
         if (this.isNonRetriableError(e))
           throw e;
       }
-      if (timeout > 0) {
-        const elapsed = (0, import_utils.monotonicTime)() - start;
-        timeout -= elapsed;
-      }
-      if (timeout < 0)
-        return { matches: options.isNot, log: (0, import_callLog.compressCallLog)(metadata.log), timedOut: true, received: lastIntermediateResult.received };
-      return await new import_progress.ProgressController(metadata, this).run(async (progress) => {
-        return await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1e3], async (continuePolling) => {
-          await this._page.performActionPreChecks(progress);
-          const { matches, received } = await this._expectInternal(progress, selector, options, lastIntermediateResult);
-          if (matches === options.isNot) {
-            return continuePolling;
-          }
-          return { matches, received };
-        });
-      }, timeout);
-    } catch (e) {
+      progress.legacyEnableTimeout();
+      return await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1e3], async (continuePolling) => {
+        await this._page.performActionPreChecks(progress);
+        const { matches, received } = await this._expectInternal(progress, selector, options, lastIntermediateResult, false);
+        if (matches === options.isNot) {
+          return continuePolling;
+        }
+        return { matches, received };
+      });
+    }, options.timeout).catch((e) => {
       if (js.isJavaScriptErrorInEvaluate(e) || (0, import_selectorParser.isInvalidSelectorError)(e))
         throw e;
       const result = { matches: options.isNot, log: (0, import_callLog.compressCallLog)(metadata.log) };
@@ -1207,15 +1225,16 @@ class Frame extends import_instrumentation.SdkObject {
       if (e instanceof import_errors.TimeoutError)
         result.timedOut = true;
       return result;
-    }
+    });
   }
-  async _expectInternal(progress, selector, options, lastIntermediateResult) {
-    const selectorInFrame = selector ? await progress.race(this.selectors.resolveFrameForSelector(selector, { strict: true })) : void 0;
+  async _expectInternal(progress, selector, options, lastIntermediateResult, noAbort) {
+    const race = (p) => noAbort ? p : progress.race(p);
+    const selectorInFrame = selector ? await race(this.selectors.resolveFrameForSelector(selector, { strict: true })) : void 0;
     const { frame, info } = selectorInFrame || { frame: this, info: void 0 };
     const world = options.expression === "to.have.property" ? "main" : info?.world ?? "utility";
-    const context = await progress.race(frame._context(world));
-    const injected = await progress.race(context.injectedScript());
-    const { log, matches, received, missingReceived } = await progress.race(injected.evaluate(async (injected2, { info: info2, options: options2, callId }) => {
+    const context = await race(frame._context(world));
+    const injected = await race(context.injectedScript());
+    const { log, matches, received, missingReceived } = await race(injected.evaluate(async (injected2, { info: info2, options: options2, callId }) => {
       const elements = info2 ? injected2.querySelectorAll(info2.parsed, document) : [];
       if (callId)
         injected2.markTargetElements(new Set(elements), callId);

package/lib/server/progress.js

@@ -61,6 +61,24 @@ class ProgressController {
     (0, import_utils.assert)(this._state === "before");
     this._state = "running";
     this.sdkObject.attribution.context?._activeProgressControllers.add(this);
+    const deadline = timeout ? Math.min((0, import_utils.monotonicTime)() + timeout, 2147483647) : 0;
+    const timeoutError = new import_errors.TimeoutError(`Timeout ${timeout}ms exceeded.`);
+    let timer;
+    const startTimer = () => {
+      if (!deadline)
+        return;
+      const onTimeout = () => {
+        if (this._state === "running") {
+          this._state = { error: timeoutError };
+          this._forceAbortPromise.reject(timeoutError);
+        }
+      };
+      const remaining = deadline - (0, import_utils.monotonicTime)();
+      if (remaining <= 0)
+        onTimeout();
+      else
+        timer = setTimeout(onTimeout, remaining);
+    };
     const progress = {
       log: (message) => {
         if (this._state === "running")
@@ -94,18 +112,19 @@ class ProgressController {
         let timer2;
         const promise = new Promise((f) => timer2 = setTimeout(f, timeout2));
         return progress.race(promise).finally(() => clearTimeout(timer2));
+      },
+      legacyDisableTimeout: () => {
+        if (this._strictMode)
+          return;
+        clearTimeout(timer);
+      },
+      legacyEnableTimeout: () => {
+        if (this._strictMode)
+          return;
+        startTimer();
       }
     };
-    let timer;
-    if (timeout) {
-      const timeoutError = new import_errors.TimeoutError(`Timeout ${timeout}ms exceeded.`);
-      timer = setTimeout(() => {
-        if (this._state === "running") {
-          this._state = { error: timeoutError };
-          this._forceAbortPromise.reject(timeoutError);
-        }
-      }, Math.min(timeout, 2147483647));
-    }
+    startTimer();
     try {
       const promise = task(progress);
       const result = this._strictMode ? await promise : await Promise.race([promise, this._forceAbortPromise]);

package/lib/utils/isomorphic/protocolMetainfo.js

@@ -159,6 +159,7 @@ const methodMetainfo = /* @__PURE__ */ new Map([
   ["Frame.fill", { title: 'Fill "{value}"', slowMo: true, snapshot: true, pausesBeforeInput: true }],
   ["Frame.focus", { title: "Focus", slowMo: true, snapshot: true }],
   ["Frame.frameElement", { internal: true }],
+  ["Frame.generateLocatorString", { internal: true }],
   ["Frame.highlight", { internal: true }],
   ["Frame.getAttribute", { internal: true, snapshot: true }],
   ["Frame.goto", { title: 'Navigate to "{url}"', slowMo: true, snapshot: true }],
@@ -212,7 +213,6 @@ const methodMetainfo = /* @__PURE__ */ new Map([
   ["ElementHandle.dispatchEvent", { title: "Dispatch event", slowMo: true, snapshot: true }],
   ["ElementHandle.fill", { title: 'Fill "{value}"', slowMo: true, snapshot: true, pausesBeforeInput: true }],
   ["ElementHandle.focus", { title: "Focus", slowMo: true, snapshot: true }],
-  ["ElementHandle.generateLocatorString", { internal: true }],
   ["ElementHandle.getAttribute", { internal: true }],
   ["ElementHandle.hover", { title: "Hover", slowMo: true, snapshot: true, pausesBeforeInput: true }],
   ["ElementHandle.innerHTML", { title: "Get HTML", snapshot: true }],