dommy 0.9.0 → 0.10.0

data/lib/dommy/interaction/driver.rb

@@ -113,12 +113,11 @@ module Dommy
       # event sequence so JS click handlers run.
       def click(selector)
         element = find(selector)
-        prevented = EventSynthesis.click(element)
-        # Browser activation behavior: an un-prevented click on a submit button
-        # runs form submission, whose JS-observable effect is a `submit` event
-        # on the owning form (a SPA handles it / preventDefaults navigation).
-        # This makes `click "button[type=submit]"` behave like a real click.
-        submit_owning_form(element) unless prevented
+        # An un-prevented click runs the element's activation behavior — a submit
+        # button submits its owning form (SubmitButtonActivation), an anchor
+        # follows its href — so `click "button[type=submit]"` / `click "a"` behave
+        # like a real click with no driver-level special-casing.
+        EventSynthesis.click(element)
         after_interaction
         element
       end
@@ -165,6 +164,87 @@ module Dommy
         result
       end
 
+      # Type into the element matching `selector` (focusing it first). Each
+      # key is a Symbol for a named key (:enter, :arrow_down, :escape, … see
+      # EventSynthesis::NAMED_KEYS) or a String typed character by character
+      # (keydown -> keypress -> beforeinput -> insertion + input -> keyup).
+      # Default actions mirror a browser's: characters insert into a text
+      # field, Backspace deletes, Enter inserts a newline in a textarea and
+      # triggers the owning form's implicit submission elsewhere. Preventing
+      # keydown / keypress / beforeinput suppresses the default action, so
+      # SPA keyboard handlers behave as they would in a browser.
+      #
+      #   browser.send_keys "#q", :arrow_down, :enter
+      #   browser.send_keys "#q", "hello"
+      def send_keys(selector, *keys)
+        send_keys_to(find(selector), *keys)
+      end
+
+      # Element-based variant of #send_keys, for hosts that already hold the
+      # element (capybara-dommy's Node#send_keys). Same semantics.
+      def send_keys_to(element, *keys)
+        EventSynthesis.focus(element)
+        keys.each { |key| dispatch_send_key(element, key) }
+        after_interaction
+        element
+      end
+
+      # Compose text through an IME, with the canonical (Chrome-like) event
+      # sequence an input method produces. `updates` are the visible
+      # composition states (e.g. ["に", "にほんご"] while converting to
+      # 日本語); each dispatches a `Process` keydown (keyCode 229),
+      # compositionupdate, the insertCompositionText beforeinput/input pair
+      # (`isComposing: true`, the field's value shows the composing text),
+      # and keyup. `commit: true` (default) then fires compositionend with
+      # `text` and leaves it in the field; `commit: false` cancels the
+      # composition, restoring the field's prior value.
+      #
+      #   browser.ime_input "#q", "日本語", updates: ["に", "にほんご"]
+      #   browser.ime_input "#q", "", updates: ["に"], commit: false
+      #
+      # A block runs after each composition state (with the update string),
+      # so a test can let virtual time pass mid-composition — e.g. prove a
+      # debounced handler that guards on `event.isComposing` stays quiet
+      # while the user pauses to pick a conversion candidate:
+      #
+      #   browser.ime_input "#q", "日本語", updates: ["に", "にほんご"] do
+      #     browser.advance_time(400)  # longer than the debounce
+      #   end
+      #
+      # Handlers that guard on `event.isComposing` (deferring work until
+      # compositionend) therefore behave exactly as they would under a real
+      # IME — something a real-browser test cannot drive deterministically.
+      def ime_input(selector, text, updates: nil, commit: true)
+        element = find(selector)
+        EventSynthesis.focus(element)
+        text = text.to_s
+        updates = Array(updates || (text.empty? ? [] : [text])).map(&:to_s)
+        base = element.respond_to?(:value) ? element.value.to_s : ""
+
+        EventSynthesis.keydown(element, "Process", "", {"keyCode" => 229})
+        EventSynthesis.compositionstart(element)
+        updates.each_with_index do |update, i|
+          EventSynthesis.keydown(element, "Process", "", {"keyCode" => 229, "isComposing" => true}) if i.positive?
+          EventSynthesis.compositionupdate(element, update)
+          field_interactor.set_composition_text(element, base, update)
+          EventSynthesis.keyup(element, "Process", "", {"isComposing" => true})
+          yield update if block_given?
+        end
+
+        if commit
+          unless text == updates.last
+            EventSynthesis.compositionupdate(element, text)
+            field_interactor.set_composition_text(element, base, text)
+          end
+          EventSynthesis.compositionend(element, text)
+        else
+          field_interactor.cancel_composition_text(element, base)
+          EventSynthesis.compositionend(element, "")
+        end
+        after_interaction
+        element
+      end
+
       # --- Matchers ---
 
       # True when an element matches `selector` in scope. `text:` keeps only
@@ -198,16 +278,77 @@ module Dommy
 
       private
 
-      # Dispatch a `submit` event on the form owning a clicked submit button.
-      # Real navigation on an un-prevented submit is a host (Session) concern;
-      # here we only surface the event so SPA handlers run.
-      def submit_owning_form(element)
-        return unless respond_to?(:submit_button?, true) && submit_button?(element)
+      # The includer (Browser / Rack::Session) may define the actual rule for
+      # "is this a submit button"; treat none as present otherwise. Used to pick
+      # the default submit button for Enter's implicit submission.
+      def submit_button_element?(element)
+        respond_to?(:submit_button?, true) && submit_button?(element)
+      end
+
+      # The form's first submit button in tree order (the one Enter's
+      # implicit-submission default action would activate), or nil for a
+      # buttonless form.
+      def default_submit_button(form)
+        form.query_selector_all("button, input").find { |el| submit_button_element?(el) }
+      end
+
+      # --- send_keys internals ---
+
+      def dispatch_send_key(element, key)
+        case key
+        when Symbol
+          named = EventSynthesis::NAMED_KEYS[key] ||
+                  raise(ArgumentError, "unknown key #{key.inspect} (known: #{EventSynthesis::NAMED_KEYS.keys.join(", ")})")
+          send_named_key(element, key, named[0], named[1])
+        when String
+          key.each_char { |char| send_character(element, char) }
+        else
+          raise ArgumentError, "send_keys takes Symbols (named keys) or Strings (typed text), got #{key.inspect}"
+        end
+      end
+
+      def send_named_key(element, name, key, code)
+        unless EventSynthesis.keydown(element, key, code)
+          case name
+          when :enter then enter_default_action(element)
+          when :space then typed_character_default_action(element, " ", "Space")
+          when :backspace then field_interactor.backspace(element)
+          end
+        end
+        EventSynthesis.keyup(element, key, code)
+      end
+
+      def send_character(element, char)
+        code = EventSynthesis.char_code(char)
+        typed_character_default_action(element, char, code) unless EventSynthesis.keydown(element, char, code)
+        EventSynthesis.keyup(element, char, code)
+      end
 
-        form = finder.form_for(element)
-        return unless form
+      # An un-prevented printable keydown fires keypress; an un-prevented
+      # keypress inserts the character (beforeinput -> value -> input).
+      def typed_character_default_action(element, char, code)
+        return if EventSynthesis.keypress(element, char, code)
 
-        form.dispatch_event(Dommy::Event.new("submit", "bubbles" => true, "cancelable" => true))
+        field_interactor.insert_text(element, char)
+      end
+
+      # Enter's default action: newline in a textarea; elsewhere the owning
+      # form's implicit submission — click the form's default (first) submit
+      # button so its handlers run, or dispatch a cancelable submit event
+      # directly when the form has no submit button (HTML implicit submission).
+      def enter_default_action(element)
+        return field_interactor.insert_text(element, "\n") if element.local_name == "textarea"
+        return unless element.respond_to?(:form) && (form = element.form)
+
+        submitter = default_submit_button(form)
+        if submitter
+          # Clicking the default submit button runs its activation behavior
+          # (form submission); a prevented click naturally submits nothing.
+          EventSynthesis.click(submitter)
+        else
+          # No submit button: HTML implicit submission with no submitter.
+          form.__run_form_submission__(nil)
+        end
       end
 
       # "no element with role …" plus the roles that WERE present (the most

data/lib/dommy/interaction/event_synthesis.rb

@@ -23,21 +23,31 @@ module Dommy
         dispatch(element, Dommy::MouseEvent.new("mouseup", mouse_init))
         event = Dommy::MouseEvent.new("click", mouse_init)
         element.dispatch_event(event)
-        event.default_prevented?
+        prevented = event.default_prevented?
+        # Run the click's activation behavior (hyperlink navigation, …) the same
+        # way Element#click does, so a synthetic/user click triggers the default
+        # action too — unless it was prevented. Checkbox/radio toggling is handled
+        # by the field interactor, not here (their activation_target is nil).
+        element.__run_click_activation_behavior__(event) if !prevented && element.respond_to?(:__run_click_activation_behavior__)
+        prevented
       end
 
+      # Run the element's focusing steps (Element#focus): moves
+      # document.activeElement and fires blur/focusout on the previously
+      # focused element plus focus/focusin here — a no-op when the element
+      # already holds focus, like a real browser.
       def focus(element)
-        dispatch(element, Dommy::FocusEvent.new("focus", "composed" => true))
-        dispatch(element, Dommy::FocusEvent.new("focusin", BUBBLES))
+        element.focus if element.respond_to?(:focus)
+        nil
       end
 
       def blur(element)
-        dispatch(element, Dommy::FocusEvent.new("blur", "composed" => true))
-        dispatch(element, Dommy::FocusEvent.new("focusout", BUBBLES))
+        element.blur if element.respond_to?(:blur)
+        nil
       end
 
-      def input(element, data = nil)
-        dispatch(element, Dommy::InputEvent.new("input", BUBBLES.merge("data" => data, "inputType" => "insertText")))
+      def input(element, data = nil, input_type = "insertText")
+        dispatch(element, Dommy::InputEvent.new("input", BUBBLES.merge("data" => data, "inputType" => input_type)))
       end
 
       def change(element)
@@ -48,6 +58,104 @@ module Dommy
         element.dispatch_event(event)
       end
 
+      # Named keys for Driver#send_keys, mapped to their KeyboardEvent
+      # key/code pairs. Aliases (:up for :arrow_up, …) match Capybara's.
+      NAMED_KEYS = {
+        enter: ["Enter", "Enter"],
+        tab: ["Tab", "Tab"],
+        escape: ["Escape", "Escape"],
+        space: [" ", "Space"],
+        backspace: ["Backspace", "Backspace"],
+        delete: ["Delete", "Delete"],
+        arrow_up: ["ArrowUp", "ArrowUp"],
+        arrow_down: ["ArrowDown", "ArrowDown"],
+        arrow_left: ["ArrowLeft", "ArrowLeft"],
+        arrow_right: ["ArrowRight", "ArrowRight"],
+        up: ["ArrowUp", "ArrowUp"],
+        down: ["ArrowDown", "ArrowDown"],
+        left: ["ArrowLeft", "ArrowLeft"],
+        right: ["ArrowRight", "ArrowRight"],
+        home: ["Home", "Home"],
+        end: ["End", "End"],
+        page_up: ["PageUp", "PageUp"],
+        page_down: ["PageDown", "PageDown"],
+      }.freeze
+
+      # keydown is cancelable: a prevented keydown suppresses the key's
+      # default action (typing, implicit submission). Returns whether it was
+      # prevented, like #click.
+      def keydown(element, key, code, extra = nil)
+        event = Dommy::KeyboardEvent.new("keydown", key_init(key, code, extra))
+        element.dispatch_event(event)
+        event.default_prevented?
+      end
+
+      # keypress fires only for keys that produce a character (legacy but
+      # still widely handled). Also cancelable; a prevented keypress
+      # suppresses the character insertion.
+      def keypress(element, key, code)
+        event = Dommy::KeyboardEvent.new("keypress", key_init(key, code))
+        element.dispatch_event(event)
+        event.default_prevented?
+      end
+
+      def keyup(element, key, code, extra = nil)
+        dispatch(element, Dommy::KeyboardEvent.new("keyup", key_init(key, code, extra)))
+      end
+
+      # IME composition events. compositionstart is cancelable per spec;
+      # update / end are not.
+      def compositionstart(element, data = "")
+        dispatch(element, Dommy::CompositionEvent.new("compositionstart", BUBBLES.merge("data" => data)))
+      end
+
+      def compositionupdate(element, data)
+        dispatch(element, Dommy::CompositionEvent.new("compositionupdate",
+          "bubbles" => true, "composed" => true, "data" => data))
+      end
+
+      def compositionend(element, data)
+        dispatch(element, Dommy::CompositionEvent.new("compositionend",
+          "bubbles" => true, "composed" => true, "data" => data))
+      end
+
+      # The input pair during composition: beforeinput then input, both with
+      # inputType insertCompositionText and isComposing true. Unlike ordinary
+      # typing, the composition beforeinput is NOT cancelable (spec).
+      def composition_input(element, data)
+        init = {"bubbles" => true, "composed" => true,
+                "data" => data, "inputType" => "insertCompositionText", "isComposing" => true}
+        dispatch(element, Dommy::InputEvent.new("beforeinput", init))
+        dispatch(element, Dommy::InputEvent.new("input", init))
+      end
+
+      # beforeinput precedes the value mutation and is cancelable (the input
+      # event that follows the mutation is not).
+      def beforeinput(element, data, input_type)
+        event = Dommy::InputEvent.new(
+          "beforeinput", BUBBLES.merge("data" => data, "inputType" => input_type)
+        )
+        element.dispatch_event(event)
+        event.default_prevented?
+      end
+
+      # The KeyboardEvent code for a typed character ("a" -> "KeyA").
+      # Best-effort: unknown characters get an empty code, like a real
+      # browser does for keys it can't map to a physical position.
+      def char_code(char)
+        case char
+        when /\A[a-zA-Z]\z/ then "Key#{char.upcase}"
+        when /\A[0-9]\z/ then "Digit#{char}"
+        when " " then "Space"
+        else ""
+        end
+      end
+
+      def key_init(key, code, extra = nil)
+        init = BUBBLES.merge("key" => key, "code" => code)
+        extra ? init.merge(extra) : init
+      end
+
       def mouse_init
         BUBBLES.merge("button" => 0, "clientX" => 0, "clientY" => 0)
       end

data/lib/dommy/interaction/field_interactor.rb

@@ -83,6 +83,66 @@ module Dommy
         select_el
       end
 
+      TEXT_ENTRY_INPUT_TYPES = %w[text search email url tel password number].freeze
+
+      def text_entry_field?(element)
+        return true if element.local_name == "textarea"
+        return false unless element.local_name == "input"
+
+        type = (element.get_attribute("type") || "text").downcase
+        TEXT_ENTRY_INPUT_TYPES.include?(type)
+      end
+
+      # Append `text` to a text-entry field's value (no caret/selection model:
+      # insertion is at the end), firing cancelable beforeinput then input.
+      # Returns whether the field accepted the insertion (false for a
+      # non-text-entry field or a prevented beforeinput) — used by Driver's
+      # send_keys to decide whether a key's default action ran.
+      def insert_text(element, text)
+        return false unless text_entry_field?(element)
+        return false if EventSynthesis.beforeinput(element, text, "insertText")
+
+        element.value = element.value.to_s + text
+        EventSynthesis.input(element, text)
+        true
+      end
+
+      # Delete the last character of a text-entry field's value. Same return
+      # contract as #insert_text.
+      def backspace(element)
+        return false unless text_entry_field?(element)
+
+        value = element.value.to_s
+        return false if value.empty?
+        return false if EventSynthesis.beforeinput(element, nil, "deleteContentBackward")
+
+        element.value = value[0...-1]
+        EventSynthesis.input(element, nil, "deleteContentBackward")
+        true
+      end
+
+      # Show composition state `update` in a text-entry field (value becomes
+      # base + update) with the insertCompositionText beforeinput/input pair.
+      # No beforeinput veto: composition inputs are not cancelable (spec).
+      # Same return contract as #insert_text.
+      def set_composition_text(element, base, update)
+        return false unless text_entry_field?(element)
+
+        element.value = base + update
+        EventSynthesis.composition_input(element, update)
+        true
+      end
+
+      # Cancel a composition: restore the field's pre-composition value and
+      # fire a deleteCompositionText input. Same return contract.
+      def cancel_composition_text(element, base)
+        return false unless text_entry_field?(element)
+
+        element.value = base
+        EventSynthesis.input(element, nil, "deleteCompositionText")
+        true
+      end
+
       private
 
       def toggle(box, checked)

data/lib/dommy/internal/child_node.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    # Shared ChildNode surface (WHATWG DOM `before` / `after` / `replaceWith`)
+    # plus the argument-coercion + childList-notification primitives those and
+    # ParentNode's own mutators build on. Included by both ParentNode (Element /
+    # Fragment / ShadowRoot) and the leaf CharacterData nodes (Text / Comment /
+    # ProcessingInstruction) — a leaf can be moved with `before`/`after` but must
+    # NOT gain `appendChild`/`insertBefore`, so those stay in ParentNode.
+    #
+    # Includers must expose `@__node__` (the backing node) and `@document`.
+    module ChildNode
+      # ChildNode#before — insert nodes as preceding siblings of `@__node__`.
+      # Follows the spec's "viable previous sibling" dance: the reference child
+      # is the first preceding sibling NOT among the argument nodes, resolved
+      # AFTER the arguments are detached (converting them into a node removes
+      # them from their old parents). Nodes are then inserted forward before the
+      # (fixed) reference — reversing would emit them backwards.
+      def child_node_before(args)
+        parent = @__node__.parent
+        return nil unless parent
+
+        arg_nodes = backend_nodes_in(args)
+        viable_prev = @__node__.previous_sibling
+        viable_prev = viable_prev.previous_sibling while viable_prev && arg_nodes.any? { |n| n == viable_prev }
+
+        nodes = args.flat_map { |arg| detach_dom_nodes(arg) }
+        ref = viable_prev.nil? ? parent.children.first : viable_prev.next_sibling
+        insert_child_nodes(nodes, ref, parent)
+        notify_child_list(added: nodes, target: parent)
+        nil
+      end
+
+      # ChildNode#after — insert nodes as following siblings of `@__node__`.
+      def child_node_after(args)
+        parent = @__node__.parent
+        return nil unless parent
+
+        arg_nodes = backend_nodes_in(args)
+        viable_next = @__node__.next_sibling
+        viable_next = viable_next.next_sibling while viable_next && arg_nodes.any? { |n| n == viable_next }
+
+        nodes = args.flat_map { |arg| detach_dom_nodes(arg) }
+        insert_child_nodes(nodes, viable_next, parent)
+        notify_child_list(added: nodes, target: parent)
+        nil
+      end
+
+      # ChildNode#replaceWith — replace `@__node__` with the given nodes.
+      def child_node_replace_with(args)
+        parent = @__node__.parent
+        return nil unless parent
+
+        arg_nodes = backend_nodes_in(args)
+        viable_next = @__node__.next_sibling
+        viable_next = viable_next.next_sibling while viable_next && arg_nodes.any? { |n| n == viable_next }
+
+        removed = @__node__
+        nodes = args.flat_map { |arg| detach_dom_nodes(arg) }
+        if @__node__.parent == parent
+          # `@__node__` survived the conversion (it wasn't among the arguments):
+          # insert the new nodes before it, then unlink it — a true replace.
+          nodes.each { |n| @__node__.add_previous_sibling(n) }
+          @__node__.unlink
+          notify_child_list(added: nodes, removed: [removed], target: parent)
+        else
+          # `@__node__` was itself an argument, so the conversion already moved
+          # it into `nodes`; pre-insert the set before the viable next sibling.
+          insert_child_nodes(nodes, viable_next, parent)
+          notify_child_list(added: nodes, target: parent)
+        end
+        nil
+      end
+
+      # WebIDL nullable DOMString coercion (`DOMString?`): JS null and undefined
+      # both become the null value, which callers treat as the empty string.
+      def nullable_dom_string(value)
+        return "" if value.nil? || (defined?(Bridge::UNDEFINED) && value.equal?(Bridge::UNDEFINED))
+
+        value.to_s
+      end
+
+      # WebIDL check for `insertBefore(node, child)`: `child` is a required but
+      # nullable Node, so a missing argument or a value that is neither a Node
+      # nor null/undefined is a TypeError before any DOM step runs. Now safe
+      # since the seeded stubs report the correct arity (2), so `.length`-based
+      # WPT helpers always pass the reference argument.
+      def validate_insert_before_ref!(args)
+        raise Bridge::TypeError, "insertBefore requires 2 arguments." if args.length < 2
+
+        ref = args[1]
+        return if ref.nil? || (defined?(Bridge::UNDEFINED) && ref.equal?(Bridge::UNDEFINED))
+        return if ref.is_a?(Dommy::Node)
+
+        raise Bridge::TypeError, "The reference child is not a Node."
+      end
+
+      private
+
+      # Insert `nodes` (raw backend nodes) into `parent` before `ref`, or append
+      # when `ref` is nil. Forward iteration against a fixed anchor preserves
+      # document order.
+      def insert_child_nodes(nodes, ref, parent)
+        if ref
+          nodes.each { |n| ref.add_previous_sibling(n) }
+        else
+          nodes.each { |n| parent.add_child(n) }
+        end
+      end
+
+      # The backing nodes of any ChildNode arguments that are already Nodes
+      # (strings / other values have none). Used to skip argument nodes when
+      # locating the viable previous / next sibling.
+      def backend_nodes_in(args)
+        args.filter_map do |arg|
+          arg.__dommy_backend_node__ if arg.respond_to?(:__dommy_backend_node__)
+        end
+      end
+
+      # Centralized MutationObserver childList notification. Defaults the
+      # target to this node; beforebegin/afterend/replaceWith/outerHTML
+      # callers pass the parent explicitly. The coordinator filters out
+      # empty added/removed sets, so this is always safe to call.
+      def notify_child_list(added: [], removed: [], target: @__node__)
+        @document.notify_child_list_mutation(
+          target_node: target,
+          added_nodes: added,
+          removed_nodes: removed
+        )
+      end
+
+      # Coerce an append/prepend/replaceChildren/before/after argument into raw
+      # backend node(s), detached from any current parent:
+      #   - Element / TextNode / CommentNode → its backing node (unlinked)
+      #   - Fragment                          → its extracted children
+      #   - String                            → a fresh text node
+      #   - anything else with a backing node → that node (unlinked)
+      #
+      # The class constants resolve at call time, so the mixin only needs to
+      # be defined before the including class bodies run.
+      def detach_dom_nodes(value)
+        case value
+        when Fragment
+          value.extract_children.map { |n| adopt_into_document(n) }
+        when String
+          [@document.create_text_node(value).__dommy_backend_node__]
+        else
+          node = value.respond_to?(:__dommy_backend_node__) ? value.__dommy_backend_node__ : nil
+          return [] unless node
+
+          # WHATWG pre-insert adopts the node into this node's document before
+          # linking it. libxml2 reassigns ownership in place during add_child, so
+          # the explicit adopt is a no-op move there; Makiri can't move a node
+          # between document arenas, so a cross-document insert must adopt (an
+          # imported copy) first. adopt_node reseats the Dommy wrapper onto the
+          # adopted node, so JS identity (`parent.appendChild(x); x` ===
+          # `parent.lastChild`) survives. Same-document: the wrapper's backend
+          # node is unchanged, so this is identical to the previous behavior.
+          detach_with_notify(node)
+          [@document.adopt_node(value).__dommy_backend_node__]
+        end
+      end
+
+      # Bring a raw backend node into this node's document (WHATWG adopt). A
+      # no-op when already same-document; otherwise Backend.adopt — in place for
+      # Nokogiri, an imported copy for Makiri (which can't move nodes between
+      # arenas). Used for fragment children, which have no standalone wrapper to
+      # reseat.
+      def adopt_into_document(node)
+        target = @document.backend_doc
+        node.document == target ? node : Backend.adopt(node, target)
+      end
+
+      # Detach a node from its current parent, queuing a childList removal
+      # record on that old parent first (WHATWG "remove" runs before the
+      # subsequent insert, so moving a node yields a removal record + an addition
+      # record). Returns the raw node, ready to be re-linked.
+      def detach_with_notify(node)
+        old_parent = node.parent
+        return node unless old_parent
+
+        # Capture the position (as wrapped nodes — the coordinator records
+        # explicit siblings verbatim) before unlinking.
+        prev_sib = node.previous_sibling && @document.wrap_node(node.previous_sibling)
+        next_sib = node.next_sibling && @document.wrap_node(node.next_sibling)
+        node.unlink
+        @document.notify_child_list_mutation(
+          target_node: old_parent,
+          added_nodes: [],
+          removed_nodes: [node],
+          previous_sibling: prev_sib,
+          next_sibling: next_sib
+        )
+        node
+      end
+    end
+  end
+end

data/lib/dommy/internal/css/cascade.rb

@@ -36,9 +36,9 @@ module Dommy
         def computed_style(element, pseudo_element: nil)
           document = element.owner_document
           return {}.freeze unless document
-          # CSSOM: an element outside the flat tree has no computed style —
+          # CSSOM: an element that is not rendered has no computed style —
           # browsers return empty strings for every property.
-          return {}.freeze if element.respond_to?(:is_connected?) && !element.is_connected?
+          return {}.freeze if not_rendered?(element)
 
           cache = style_cache(document)
           if pseudo_element
@@ -50,6 +50,48 @@ module Dommy
           end
         end
 
+        # An element is "not rendered" (and thus has an empty computed style, per
+        # CSSOM getComputedStyle) when it is disconnected, outside the flat tree
+        # (an unslotted light child of a shadow host), or inside a non-rendered
+        # frame (a `display:none` / disconnected `<iframe>`).
+        def not_rendered?(element)
+          return true if element.respond_to?(:is_connected?) && !element.is_connected?
+          return true if outside_flat_tree?(element)
+
+          in_non_rendered_frame?(element)
+        end
+
+        # Walk flat-tree parents: a light child of a shadow host is in the flat
+        # tree only if assigned to a slot, so an unslotted one (and its subtree)
+        # is outside it.
+        def outside_flat_tree?(element)
+          node = element
+          while node.respond_to?(:parent_element) && (host = node.parent_element)
+            if host.respond_to?(:shadow_root) && host.shadow_root &&
+               node.respond_to?(:assigned_slot) && node.assigned_slot.nil?
+              return true
+            end
+
+            node = host
+          end
+          false
+        end
+
+        # Follow the frame chain up to the top document; the element is not
+        # rendered if any hosting frame is disconnected or `display:none`.
+        def in_non_rendered_frame?(element)
+          doc = element.owner_document
+          seen = 0
+          while doc && (view = (doc.default_view if doc.respond_to?(:default_view))) &&
+                (frame = view.frame_element) && (seen += 1) < 64
+            return true if frame.respond_to?(:is_connected?) && !frame.is_connected?
+            return true if computed_style(frame)["display"] == "none"
+
+            doc = frame.owner_document
+          end
+          false
+        end
+
         # Cheap per-generation gate used by visibility checks: does the
         # document carry any author CSS at all? When it doesn't (and for
         # makiri-less installs), the HTML-level fast path is already exact