capybara-lightpanda 0.2.1 → 0.3.0

data/lib/capybara/lightpanda/javascripts/polyfills.js

@@ -5,6 +5,78 @@
 (function () {
   "use strict";
 
+  // ── Bug #7 — HTMLFormElement / HTMLButtonElement / HTMLInputElement form-* IDL gaps ──
+  // Lightpanda doesn't expose `form.enctype`, `form.method`, `form.action`,
+  // `form.target`, nor the submitter-side `formEnctype` / `formMethod` /
+  // `formAction` / `formTarget` overrides. Per WHATWG HTML these must always
+  // return a string (with the spec's missing-value default) so consumers can
+  // call `.toLowerCase()` etc. directly. Turbo's `FormSubmission` constructor
+  // does exactly that and crashes with `Cannot read properties of undefined
+  // (reading 'toLowerCase')` when it touches enctype.
+  //
+  // Polyfill strategy: only define the IDL getter when it's missing on the
+  // prototype, so a future Lightpanda nightly that adds native support wins
+  // automatically. Each getter falls back to the underlying attribute, with
+  // the spec's default if the attribute is absent. For submitter overrides
+  // (formEnctype, formMethod, etc.) we return the empty string when the
+  // override attribute is unset — Turbo and Hotwire all use the
+  // `submitter.formX || form.X` idiom, which resolves correctly when the
+  // submitter side returns "".
+  (function patchFormIDL() {
+    var ENCTYPE_VALUES = ["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"];
+    function normEnctype(v) {
+      if (!v) return "application/x-www-form-urlencoded";
+      v = String(v).toLowerCase();
+      return ENCTYPE_VALUES.indexOf(v) >= 0 ? v : "application/x-www-form-urlencoded";
+    }
+    function normMethod(v) {
+      if (!v) return "get";
+      v = String(v).toLowerCase();
+      return (v === "post" || v === "dialog") ? v : "get";
+    }
+    function defineIfMissing(proto, name, getter) {
+      if (!proto || name in proto) return;
+      try { Object.defineProperty(proto, name, { configurable: true, enumerable: true, get: getter }); } catch (_) {}
+    }
+    if (typeof HTMLFormElement !== "undefined") {
+      var fp = HTMLFormElement.prototype;
+      defineIfMissing(fp, "enctype", function () { return normEnctype(this.getAttribute("enctype")); });
+      defineIfMissing(fp, "method",  function () { return normMethod(this.getAttribute("method")); });
+      defineIfMissing(fp, "action",  function () {
+        var a = this.getAttribute("action");
+        if (a == null || a === "") return (this.ownerDocument && this.ownerDocument.URL) || "";
+        try { return new URL(a, (this.ownerDocument && this.ownerDocument.URL) || undefined).href; }
+        catch (_) { return a; }
+      });
+      defineIfMissing(fp, "target",  function () { return this.getAttribute("target") || ""; });
+    }
+    function patchSubmitter(Ctor) {
+      if (typeof Ctor === "undefined") return;
+      var p = Ctor.prototype;
+      // Empty string is the spec's missing-value default for the submitter-side
+      // IDL attrs — keep Turbo's `submitter.formX || form.X` idiom flowing
+      // through to the form's value.
+      defineIfMissing(p, "formEnctype", function () {
+        var v = this.getAttribute("formenctype");
+        return v == null ? "" : normEnctype(v);
+      });
+      defineIfMissing(p, "formMethod", function () {
+        var v = this.getAttribute("formmethod");
+        return v == null ? "" : normMethod(v);
+      });
+      defineIfMissing(p, "formAction", function () {
+        var a = this.getAttribute("formaction");
+        if (a == null || a === "") return "";
+        try { return new URL(a, (this.ownerDocument && this.ownerDocument.URL) || undefined).href; }
+        catch (_) { return a; }
+      });
+      defineIfMissing(p, "formTarget", function () { return this.getAttribute("formtarget") || ""; });
+      defineIfMissing(p, "formNoValidate", function () { return this.hasAttribute("formnovalidate"); });
+    }
+    patchSubmitter(typeof HTMLButtonElement !== "undefined" ? HTMLButtonElement : null);
+    patchSubmitter(typeof HTMLInputElement  !== "undefined" ? HTMLInputElement  : null);
+  })();
+
   // ── Bug #4 — HTMLDialogElement.{showModal, show, close} non implémentés ──
   // https://html.spec.whatwg.org/multipage/interactive-elements.html#the-dialog-element
   if (typeof HTMLDialogElement !== "undefined") {
@@ -35,47 +107,106 @@
     }
   }
 
-  // ── Bug #3 (narrower than originally diagnosed; verified 2026-05-04 against build 6005) ──
-  // Native dispatch DOES propagate to ancestors with event.target preserved — but if
-  // ANY listener throws, Lightpanda halts the whole dispatch path (incl. the bubble
-  // phase) instead of reporting the exception and continuing per DOM §2.9 step 4.
-  // Stimulus / Turbo Drive listeners that throw silently swallow document-level
-  // delegation. Workaround: catch the propagated JsException and re-walk parents
-  // manually, spoofing event.target via Object.defineProperty for delegated handlers.
-  (function patchDispatch() {
-    if (!window.EventTarget || !EventTarget.prototype.dispatchEvent) return;
-    var orig = EventTarget.prototype.dispatchEvent;
+  // ── Bug #8 (added 2026-05-05) — sync remove + re-add lost across dispatch phases ──
+  // WHATWG DOM specifies that each phase of a dispatch snapshots `currentTarget`'s
+  // listener list AT THAT PHASE. Listeners removed and re-added during the capture
+  // phase correctly appear in the bubble-phase snapshot in Chrome/Cuprite. Lightpanda
+  // takes the snapshot once at dispatch start, so a remove+add during capture loses
+  // the listener for the in-flight bubble. This breaks Turbo's `FormSubmitObserver`
+  // pattern, where `submitCaptured` does `remove+add` on its own `submitBubbled` to
+  // ensure that handler runs LAST in bubble — under Lightpanda, `submitBubbled` is
+  // dropped entirely and Turbo never intercepts form submissions.
+  //
+  // Native form submission via `requestSubmit()` doesn't route through JS-exposed
+  // `dispatchEvent`, so we can't detect "in-flight dispatch" by patching that. The
+  // workaround instead targets the remove+add idiom directly: defer every
+  // `removeEventListener` to a microtask. When `addEventListener` runs in the same
+  // synchronous turn with the SAME (target, type, fn, capture), we cancel the
+  // pending remove — the listener was never actually unregistered, so the in-flight
+  // bubble snapshot still contains it. Genuine removes (no matching add follows)
+  // happen at end-of-tick, indistinguishable from the unpatched behavior modulo
+  // tick boundary.
+  //
+  // Scope: only capture-phase `submit` listeners, the exact tuple Turbo Drive
+  // uses. This avoids changing observable DOM semantics for arbitrary
+  // remove/dispatch sequences elsewhere on the page — synchronous remove +
+  // dispatch outside this narrow tuple still fires the native `removeEventListener`
+  // path immediately.
+  //
+  // Trade-offs (within the narrowed scope):
+  //   • Code that removes a capture-phase submit listener and then reads
+  //     listener state synchronously before the microtask flush will see it
+  //     as still-attached. No known framework does this on `submit`.
+  //   • If something removes capture-phase submit listener X then adds Y of
+  //     the same type/capture before the flush, the add happens immediately
+  //     but the deferred remove fires after, removing X *after* Y is
+  //     registered. Y persists, X is gone. Same end state as without the
+  //     polyfill, just reordered in time.
+  (function patchListenerLifecycle() {
+    if (!window.EventTarget || !EventTarget.prototype.addEventListener) return;
+    if (typeof Promise === "undefined") return; // need microtasks
+    var origAdd    = EventTarget.prototype.addEventListener;
+    var origRemove = EventTarget.prototype.removeEventListener;
+
+    function captureFlag(opts) {
+      return opts === true || (opts && typeof opts === "object" && opts.capture === true);
+    }
 
-    EventTarget.prototype.dispatchEvent = function (event) {
-      try {
-        return orig.call(this, event);
-      } catch (err) {
-        if (!event || !event.bubbles || !this.parentNode) throw err;
+    function inScope(type, capture) {
+      return type === "submit" && capture === true;
+    }
 
-        var originalTarget = this;
-        try {
-          Object.defineProperty(event, "target", {
-            value: originalTarget,
-            configurable: true,
-          });
-        } catch (_) { /* target not redefinable — continue anyway */ }
+    var pending = [];      // [{ target, type, fn, capture, cancelled }]
+    var flushScheduled = false;
 
-        var node = this.parentNode;
-        while (node) {
+    function scheduleFlush() {
+      if (flushScheduled) return;
+      flushScheduled = true;
+      Promise.resolve().then(function () {
+        flushScheduled = false;
+        var queue = pending;
+        pending = [];
+        for (var i = 0; i < queue.length; i++) {
+          var r = queue[i];
+          if (r.cancelled) continue;
           try {
-            Object.defineProperty(event, "currentTarget", {
-              value: node,
-              configurable: true,
-            });
+            origRemove.call(r.target, r.type, r.fn, r.capture);
           } catch (_) {}
-          try {
-            orig.call(node, event);
-          } catch (_) { /* ignore intermediate crashes; keep propagating */ }
-          if (event.cancelBubble) break;
-          node = node.parentNode || node.host || null;
         }
-        return !event.defaultPrevented;
+      });
+    }
+
+    EventTarget.prototype.removeEventListener = function (type, fn, opts) {
+      var capture = captureFlag(opts);
+      if (!fn || !inScope(type, capture)) return origRemove.call(this, type, fn, opts);
+      pending.push({
+        target:    this,
+        type:      type,
+        fn:        fn,
+        capture:   capture,
+        cancelled: false,
+      });
+      scheduleFlush();
+    };
+
+    EventTarget.prototype.addEventListener = function (type, fn, opts) {
+      if (!fn) return origAdd.call(this, type, fn, opts);
+      var capture = captureFlag(opts);
+      if (inScope(type, capture)) {
+        // Cancel a pending remove for the same tuple (LIFO so the most recent
+        // pending remove wins for the remove-then-add idiom). Always call
+        // native add too: addEventListener is idempotent per DOM spec, and
+        // skipping risks losing the listener on a later unmatched remove.
+        for (var i = pending.length - 1; i >= 0; i--) {
+          var r = pending[i];
+          if (r.cancelled) continue;
+          if (r.target === this && r.type === type && r.fn === fn && r.capture === capture) {
+            r.cancelled = true;
+            break;
+          }
+        }
       }
+      return origAdd.call(this, type, fn, opts);
     };
   })();
 })();

data/lib/capybara/lightpanda/node.rb

@@ -237,6 +237,8 @@ module Capybara
 
       def backend_node_id
         @backend_node_id ||= driver.browser.backend_node_id(@remote_object_id)
+      rescue BrowserError
+        nil
       end
 
       private
@@ -363,13 +365,6 @@ module Capybara
         end
       end
 
-      # Native `this.click()` reaches all ancestors on the happy path, but if any
-      # listener throws (Stimulus / Turbo edge cases) Lightpanda halts dispatch
-      # instead of reporting the exception per DOM §2.9 step 4 (see UPSTREAM_BUGS.md
-      # Bug #3). Dispatching via JS routes through `polyfills.js`'s patchDispatch
-      # IIFE, which catches the throw and re-walks parents manually so document-
-      # level delegated handlers still see the event.
-      #
       # We dispatch a `MouseEvent` (not a generic `Event`) because Turbo's link
       # and form interceptors guard with `event instanceof MouseEvent` before
       # they consider intercepting — a synthetic `Event('click')` is silently
@@ -377,33 +372,38 @@ module Capybara
       # the manual default action below, which does a full-page navigation
       # instead of a frame swap.
       #
-      # For submit buttons (`<button type=submit>`, `<input type=submit>`,
-      # `<input type=image>`): route through `form.requestSubmit(this)` so the
-      # browser dispatches a real `SubmitEvent` with submitter set, honors the
-      # submitter's `formaction` / `formmethod` / `formenctype`, and includes
-      # the submitter's name/value in the form data. A manual
-      # `dispatchEvent(new Event('submit'))` + `form.submit()` would lose all of
-      # that and break Turbo Drive / Hotwire form handling. We can't rely on
-      # the synthetic click's default action because synthetic events don't
-      # trigger the implicit form-submission default action per DOM spec.
+      # Submit buttons (`<input type=submit>`, `<input type=image>`,
+      # `<button type=submit>`): native click on the dispatched MouseEvent
+      # already runs the form-submission default action via Frame.submitForm
+      # in Lightpanda (extension of PR #2312 for image to all submit
+      # variants). A manual `form.requestSubmit(this)` here would fire a
+      # second SubmitEvent and double-submit the form — observed on nightly
+      # 6167 as duplicate `turbo:submit-start` events; the first request
+      # gets aborted by the second and Turbo never renders the response.
       CLICK_JS = <<~JS
         function() {
           var EventCtor = (typeof MouseEvent !== 'undefined') ? MouseEvent : Event;
           var clickEvt = new EventCtor('click', { bubbles: true, cancelable: true });
-          var notCancelled = true;
-          try {
-            notCancelled = this.dispatchEvent(clickEvt);
-          } catch (e) { /* patchDispatch in polyfills.js rescues bubble phase */ }
+          var notCancelled = this.dispatchEvent(clickEvt);
           if (!notCancelled || clickEvt.defaultPrevented) return;
           var tag = this.tagName;
-          var type = (this.type || '').toLowerCase();
-          var isSubmitButton =
-            (tag === 'BUTTON' && (type === 'submit' || type === '')) ||
-            (tag === 'INPUT' && (type === 'submit' || type === 'image'));
-          if (isSubmitButton && this.form) {
-            this.form.requestSubmit(this);
-          } else if (tag === 'A' && this.href && this.target !== '_blank') {
-            window.location.href = this.href;
+          if (tag === 'A' && this.href && this.target !== '_blank') {
+            // Same-document fragment-only navigation: just update hash (or do
+            // nothing if identical). Mirrors Chrome — assigning location.href
+            // to a same-document URL on Lightpanda triggers a real navigation
+            // tick that cancels pending setTimeout callbacks and clears form
+            // values, which breaks any test driving DOM updates from a click
+            // handler on `<a href="#...">`.
+            var dest = new URL(this.href, document.baseURI);
+            var here = new URL(window.location.href);
+            if (dest.origin === here.origin && dest.pathname === here.pathname &&
+                dest.search === here.search) {
+              if (dest.hash !== here.hash) {
+                window.location.hash = dest.hash;
+              }
+            } else {
+              window.location.href = this.href;
+            }
           }
         }
       JS

data/lib/capybara/lightpanda/process.rb

@@ -8,8 +8,8 @@ module Capybara
       READY_PATTERN = /server running.*address\s*=\s*(\d+\.\d+\.\d+\.\d+:\d+)/m
       ADDRESS_IN_USE_PATTERN = /err=AddressInUse/
 
-      # Floor for the cookie/navigation/redirect/modal/keyboard/css/forms
-      # fixes the gem now relies on: PR #2255 (Network.clearBrowserCookies
+      # Floor for the cookie/navigation/redirect/modal/keyboard/css/forms/dispatch/
+      # xpath/history fixes the gem now relies on: PR #2255 (Network.clearBrowserCookies
       # empty params + Network.getAllCookies), PR #2257
       # (window.location.pathname/.search assignment triggers navigation),
       # PR #2265 (URL fragment inherited across fragment-less redirect),
@@ -23,10 +23,17 @@ module Capybara
       # on labeled control), PR #2286 (HTML constraint validation API:
       # el.validity, validationMessage, checkValidity, reportValidity),
       # PR #2342 (<summary> click toggles parent <details>.open),
-      # PR #2352 (HTMLInputElement.pattern + patternMismatch via V8 RegExp).
-      # Build 6051 = main HEAD d360fcc0 (2026-05-04); ships in nightly
-      # published 2026-05-05 ~03:30 UTC for all four platforms.
-      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("6051")
+      # PR #2352 (HTMLInputElement.pattern + patternMismatch via V8 RegExp),
+      # PR #2368 (events: report listener exceptions instead of halting
+      # dispatch — lets us drop the polyfills.js patchDispatch IIFE),
+      # PR #2289 (Page.getNavigationHistory + Page.navigateToHistoryEntry —
+      # lets us drop the history.back()/history.forward() JS workaround in
+      # Browser#back / #forward), PR #2305 (XPath 1.0: Document.evaluate,
+      # XPathResult, XPathEvaluator, XPathExpression — lets us drop the
+      # ~700 LOC XPath polyfill in javascripts/index.js).
+      # Build 6109 = main HEAD cfcfe4ee (2026-05-11, after PR #2289 and
+      # PR #2305 merges); will ship in nightly published 2026-05-12 ~03:30 UTC.
+      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("6109")
 
       attr_reader :pid, :ws_url, :version, :nightly_build
 

data/lib/capybara/lightpanda/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Lightpanda
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-lightpanda
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Navid Emad
@@ -115,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Capybara driver for the Lightpanda headless browser
 test_files: []