dommy 0.8.0 → 0.9.0

data/lib/dommy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dommy
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/lib/dommy/window.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require "uri"
+
+require_relative "internal/css/cascade"
+require_relative "internal/css/media_query"
+
 # Dommy — a happy-dom-style DOM polyfill in pure Ruby. Backbone is
 # Nokogiri::HTML5 plus a small scheduler/event-loop layer.
 #
@@ -20,7 +25,14 @@ module Dommy
 
     attr_reader :document, :scheduler, :location, :globals, :custom_elements, :navigator
 
-    def initialize(host = nil, nokogiri_doc: nil)
+    # Opt into best-effort geometry: when true, getBoundingClientRect / client* /
+    # offset* return non-zero estimates from a cheap pseudo-layout (viewport width
+    # + text content) instead of all-zero. Off by default so the no-layout
+    # contract (and the tests asserting 0) is unchanged; a browser front end
+    # (dommynx) turns it on so sites that bail on all-zero rects can proceed.
+    attr_accessor :approximate_layout
+
+    def initialize(host = nil, backend_doc: nil)
       @host = host
       @scheduler = Scheduler.new
       @crypto = Crypto.new(self)
@@ -35,8 +47,15 @@ module Dommy
       # production code stays on the typed accessors. Kept last in the read
       # fallback so it can't shadow intentional getters.
       @globals = {}
-      @document = Document.new(host, nokogiri_doc: nokogiri_doc)
+      @document = Document.new(host, backend_doc: backend_doc)
       @document.default_view = self
+      # Per the HTML parsing algorithm, a <template>'s contents are parsed into a
+      # separate "template contents" DocumentFragment, not as children of the
+      # element. Backends (libxml2) leave them as direct children, so migrate
+      # eagerly at page-load time — before any framework walks the tree. Without
+      # this, a tree-walk (Alpine's x-for/x-if scan, etc.) descends into the
+      # template's inert content and evaluates directives there out of scope.
+      @document.migrate_template_descendants(@document.backend_doc)
       @custom_elements = CustomElementRegistry.new(self)
       @navigator = Navigator.new(self)
       # All JS global constructors (`new Event()`, `new URL()`, ...) live in a
@@ -95,6 +114,14 @@ module Dommy
         @custom_elements
       when "navigator"
         @navigator
+      when "screen"
+        @screen ||= Screen.new(self)
+      when "innerWidth", "outerWidth"
+        media_environment.viewport_width
+      when "innerHeight", "outerHeight"
+        media_environment.viewport_height
+      when "devicePixelRatio"
+        media_environment.device_pixel_ratio
       when "scrollX", "pageXOffset"
         @scroll_x || 0
       when "scrollY", "pageYOffset"
@@ -102,8 +129,18 @@ module Dommy
       when "scrollMaxX", "scrollMaxY"
         # No real content box to scroll past, so the max offset is 0.
         0
+      when "event"
+        # The legacy global current-event is *absent* (undefined, not null) when
+        # no event is being dispatched, so feature detection like
+        # `window.event === undefined` (React's getCurrentEventPriority) takes the
+        # not-supported path instead of dereferencing null. An explicitly-set
+        # value still wins.
+        @globals.key?("event") ? @globals["event"] : Bridge::UNDEFINED
       else
-        @globals[key]
+        # A stashed global wins (even if its value is nil/null); a key never set
+        # is genuinely absent → ABSENT so JS sees `undefined` and `"x" in window`
+        # is false (feature detection like `isUndefined(window.Vue)` works).
+        @globals.key?(key) ? @globals[key] : Bridge::ABSENT
       end
     end
 
@@ -122,10 +159,11 @@ module Dommy
 
     include Bridge::Methods
     js_methods %w[
-      fetch encodeURIComponent decodeURIComponent addEventListener removeEventListener
+      fetch encodeURIComponent decodeURIComponent btoa atob addEventListener removeEventListener
       dispatchEvent setTimeout clearTimeout setInterval clearInterval requestAnimationFrame
       cancelAnimationFrame queueMicrotask requestIdleCallback cancelIdleCallback structuredClone
-      matchMedia getComputedStyle scroll scrollTo scrollBy
+      matchMedia getComputedStyle scroll scrollTo scrollBy resizeTo
+      alert confirm prompt open reportError getSelection postMessage
     ]
     def __js_call__(method, args)
       case method
@@ -135,6 +173,10 @@ module Dommy
         Internal::GlobalFunctions.encode_uri_component(args[0])
       when "decodeURIComponent"
         Internal::GlobalFunctions.decode_uri_component(args[0])
+      when "btoa"
+        Internal::GlobalFunctions.btoa(args[0])
+      when "atob"
+        Internal::GlobalFunctions.atob(args[0])
       when "addEventListener"
         add_event_listener(args[0], args[1], args[2])
       when "removeEventListener"
@@ -164,15 +206,27 @@ module Dommy
       when "matchMedia"
         MediaQueryList.new(self, args[0].to_s)
       when "getComputedStyle"
-        # No CSS engine — return the element's inline style. That
-        # covers `getComputedStyle(el).getPropertyValue("color")` for
-        # values the test set inline via `el.style.color = "..."`.
-        target = args[0]
-        target.respond_to?(:style) ? target.style : nil
+        get_computed_style(args[0], args[1])
+      when "resizeTo"
+        resize_to(args[0], args[1])
       when "scroll", "scrollTo"
         scroll_to(*args)
       when "scrollBy"
         scroll_by(*args)
+      when "alert"
+        nil # headless: no dialog (happy-dom semantics)
+      when "confirm"
+        false # no user -> treated as "Cancel"
+      when "prompt"
+        nil # no user input
+      when "open"
+        nil # cannot open a new browsing context headlessly
+      when "reportError"
+        nil # swallow programmatic error reports (no uncaught surfacing here)
+      when "getSelection"
+        document&.get_selection
+      when "postMessage"
+        post_message(args[0])
       else
         # Additional window-level methods (fetch, location, history,
         # Promise, MutationObserver, etc.) arrive in later sessions.
@@ -199,6 +253,80 @@ module Dommy
       dispatch_event(event)
     end
 
+    # --- Viewport / media environment (cssom-view) ---
+
+    # The media-feature environment matchMedia and @media evaluate against
+    # (viewport 1280x720, light scheme, dpr 1 by default). Mutable; after a
+    # direct mutation call __internal_media_environment_changed__ to propagate —
+    # resize_to does both for the viewport.
+    def media_environment
+      @media_environment ||= Internal::CSS::MediaQuery::Environment.default
+    end
+
+    def inner_width = media_environment.viewport_width
+    def inner_height = media_environment.viewport_height
+
+    # Resolve a (possibly relative) URL against the document base URL — the
+    # API base URL of this window's environment, as fetch/XHR use when
+    # constructing a request. Returns the input unchanged if it can't resolve.
+    def __internal_resolve_url__(url)
+      base = @document&.base_uri
+      return url.to_s if base.to_s.empty?
+
+      URI.join(base.to_s, url.to_s).to_s
+    rescue URI::Error
+      url.to_s
+    end
+
+    # The path (with query) of a URL — lets a stub keyed by a path ("/api")
+    # match its resolved absolute form ("http://host/api").
+    def __internal_url_path__(url)
+      uri = URI.parse(url.to_s)
+      uri.query ? "#{uri.path}?#{uri.query}" : uri.path
+    rescue URI::Error
+      url.to_s
+    end
+
+    # Resize the virtual viewport: updates the environment, invalidates
+    # computed styles (@media), re-evaluates handed-out MediaQueryLists
+    # (firing their `change` events), and fires the window `resize` event.
+    def resize_to(width, height)
+      media_environment.viewport_width = width.to_i
+      media_environment.viewport_height = height.to_i
+      __internal_media_environment_changed__
+      dispatch_event(Event.new("resize"))
+      nil
+    end
+
+    def __internal_media_environment_changed__
+      @document&.__internal_bump_style_generation__
+      (@media_query_lists || []).each(&:__internal_environment_changed__)
+      nil
+    end
+
+    def __internal_register_media_query_list__(mql)
+      (@media_query_lists ||= []) << mql
+      nil
+    end
+
+    # CSSOM getComputedStyle. With the makiri-backed CSS parser available
+    # this resolves the full cascade (UA sheet + <style> sheets + style
+    # attribute); without it, falls back to the element's inline style (the
+    # historical behavior). A pseudo-element argument yields an empty
+    # declaration (Dommy renders no ::before/::after boxes).
+    def get_computed_style(element, pseudo_element = nil)
+      return nil unless element
+
+      if Internal::CSS::Parser.available?
+        pseudo = pseudo_element.to_s
+        Internal::CSS::ComputedStyleDeclaration.new(
+          element, pseudo_element: pseudo.empty? ? nil : pseudo
+        )
+      else
+        element.respond_to?(:style) ? element.style : nil
+      end
+    end
+
     private
 
     # Virtual scroll position. There's no real layout, but tracking a logical
@@ -216,6 +344,15 @@ module Dommy
       update_scroll(x, y)
     end
 
+    # `window.postMessage`: deliver a structured-cloned `message` to this window's
+    # own message handlers from a TASK (the "post message" task source, not a
+    # microtask) — so it lands in a later event-loop turn, as the spec requires.
+    def post_message(message)
+      data = Dommy.structured_clone(message)
+      @scheduler.set_timeout(proc { dispatch_event(MessageEvent.new("message", "data" => data)) }, 0)
+      nil
+    end
+
     # Accept either positional `(x, y)` or a `{ left:, top: }` options dict.
     def parse_scroll_args(args, cur_x, cur_y, relative:)
       if args[0].is_a?(Hash)
@@ -256,6 +393,20 @@ module Dommy
       0
     end
 
+    # WebIDL coercion for the `Text`/`Comment` constructor's `optional DOMString
+    # data = ""`: an omitted or undefined argument uses the default (""), but an
+    # explicit `null` stringifies to "null" per ToString. (Omitted arrives as an
+    # empty args list; explicit JS null arrives as a Ruby nil element.)
+    def node_data_arg(args)
+      return "" if args.empty?
+
+      value = args[0]
+      return "" if defined?(Bridge::UNDEFINED) && value.equal?(Bridge::UNDEFINED)
+      return "null" if value.nil?
+
+      value.to_s
+    end
+
     # Build the JS-global constructor map. Blocks are lazy (run at `new X()`
     # time), so they may reference `win` / `@document` freely.
     def build_constructors
@@ -281,8 +432,13 @@ module Dommy
         # `new Document()` — a fresh empty document (content type application/xml
         # per the DOM Standard, so it behaves as a non-HTML document).
         "Document" => Bridge::Constructor.new do
-          Document.new(nil, nokogiri_doc: Backend.document_class.new).tap { |d| d.content_type = "application/xml" }
+          Document.new(nil, backend_doc: Backend.empty_xml_document).tap { |d| d.content_type = "application/xml" }
         end,
+        # `new Text(data?)` / `new Comment(data?)` / `new DocumentFragment()` —
+        # create the node in this window's associated document (DOM Standard).
+        "Text" => Bridge::Constructor.new { |args| win.document.create_text_node(node_data_arg(args)) },
+        "Comment" => Bridge::Constructor.new { |args| win.document.create_comment(node_data_arg(args)) },
+        "DocumentFragment" => Bridge::Constructor.new { |_args| win.document.create_document_fragment },
         "Event" => Bridge::Constructor.new { |args| Event.new(args[0], args[1]) },
         "CustomEvent" => Bridge::Constructor.new { |args| CustomEvent.new(args[0], args[1]) },
         "MessageEvent" => Bridge::Constructor.new { |args| MessageEvent.new(args[0], args[1]) },
@@ -290,8 +446,16 @@ module Dommy
         "CloseEvent" => Bridge::Constructor.new { |args| CloseEvent.new(args[0], args[1]) },
         "MouseEvent" => Bridge::Constructor.new { |args| MouseEvent.new(args[0], args[1]) },
         "KeyboardEvent" => Bridge::Constructor.new { |args| KeyboardEvent.new(args[0], args[1]) },
+        "PromiseRejectionEvent" => Bridge::Constructor.new { |args| PromiseRejectionEvent.new(args[0], args[1]) },
+        "ErrorEvent" => Bridge::Constructor.new { |args| ErrorEvent.new(args[0], args[1]) },
         "EventTarget" => Bridge::Constructor.new { |_args| StandaloneEventTarget.new },
         "Error" => Bridge::Constructor.new { |args| ErrorValue.new(args[0]) },
+        # The host PromiseConstructor backs Ruby-side promises (fetch, the
+        # scheduler bridge). It must NOT shadow the engine's native Promise on the
+        # JS side, though — `window.Promise` is forced to globalThis.Promise in
+        # host_runtime.js's exposeConstructorsOnWindow so feature detection
+        # (core-js et al.) sees a real Promise (=== globalThis.Promise) and does
+        # not swap in a polyfill whose microtasks the host can't flush.
         "Promise" => Bridge::PromiseConstructor.new(win),
         "MutationObserver" => Bridge::Constructor.new { |args| MutationObserver.new(win, args[0]) },
         "AbortController" => Bridge::Constructor.new { |_args| AbortController.new },
@@ -352,6 +516,30 @@ module Dommy
         "URLPattern" => Bridge::Constructor.new { |args| URLPattern.new(args[0], args[1]) },
         "Range" => Bridge::Constructor.new { |_args| Range.new(@document) },
         "URL" => url,
+        # Legacy named constructors (HTML `[LegacyFactoryFunction]`): each builds
+        # the corresponding element. `new Image()` is `<img>`, `new Audio()` is
+        # `<audio>` (preload="auto"), `new Option()` is `<option>`. The JS side
+        # exposes the globals with the target interface's prototype so e.g.
+        # `new Image() instanceof HTMLImageElement` holds.
+        "Image" => Bridge::Constructor.new { |args|
+          img = win.document.create_element("img")
+          img.set_attribute("width", args[0].to_s) unless args[0].nil?
+          img.set_attribute("height", args[1].to_s) unless args[1].nil?
+          img
+        },
+        "Audio" => Bridge::Constructor.new { |args|
+          audio = win.document.create_element("audio")
+          audio.set_attribute("preload", "auto")
+          audio.set_attribute("src", args[0].to_s) unless args[0].nil?
+          audio
+        },
+        "Option" => Bridge::Constructor.new { |args|
+          opt = win.document.create_element("option")
+          opt.text = args[0].to_s unless args[0].nil? || args[0].to_s.empty?
+          opt.value = args[1].to_s if args.length >= 2 && !args[1].nil?
+          opt.selected = true if args[2] || args[3] # defaultSelected / selectedness
+          opt
+        },
       }
     end
   end

data/lib/dommy/worker.rb

@@ -35,10 +35,13 @@ module Dommy
       return if @terminated
 
       cloned = Dommy.structured_clone(data)
-      @window.scheduler.queue_microtask(
+      # The "post message" task source — a task, not a microtask (a real worker
+      # delivers across the agent boundary in a later event-loop turn).
+      @window.scheduler.set_timeout(
         proc do
           @worker_side_handlers.each { |h| invoke(h, [{"data" => cloned}]) }
-        end
+        end,
+        0
       )
 
       nil
@@ -63,10 +66,11 @@ module Dommy
     # Worker-side: deliver a message to the main-side `message` event.
     def __test_post_to_main__(data)
       cloned = Dommy.structured_clone(data)
-      @window.scheduler.queue_microtask(
+      @window.scheduler.set_timeout(
         proc do
           dispatch_event(MessageEvent.new("message", "data" => cloned))
-        end
+        end,
+        0
       )
 
       nil

data/lib/dommy/xml_http_request.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "data_uri"
 
 module Dommy
   # `XMLHttpRequest` polyfill. Consults the same stub maps that
@@ -68,7 +69,8 @@ module Dommy
     def open(method, url, async = true, _user = nil, _password = nil)
       reset_state
       @method = method.to_s.upcase
-      @url = url.to_s
+      # XHR resolves the request URL against the document base URL, like fetch.
+      @url = @window.__internal_resolve_url__(url.to_s)
       @async = async.nil? ? true : !!async
       @request_headers = {}
       transition(OPENED)
@@ -95,12 +97,30 @@ module Dommy
       gen = @generation
       dispatch_event(ProgressEvent.new("loadstart"))
 
-      entry = lookup_stub
+      entry = data_uri_entry || lookup_stub
       track_globals
 
+      # Async (live network): the handler returns a deferred whose response
+      # arrives off-thread and is delivered on the page thread. The request stays
+      # open until then. The sync path (stubs / cache / data:) delivers inline.
+      if entry.respond_to?(:on_complete)
+        entry.on_complete { |resolved| deliver_resolved(resolved, gen) }
+        return nil
+      end
+
+      deliver_resolved(entry, gen)
+      nil
+    end
+
+    # Deliver a resolved response entry (nil -> 404), honoring abort/reopen (the
+    # generation may have changed) and a simulated `delay`. Shared by the
+    # synchronous path and an async deferred completion.
+    def deliver_resolved(entry, gen)
+      return unless active?(gen)
+
       if entry.nil?
         deliver(body: "not found", status: 404, status_text: "Not Found", headers: {})
-        return nil
+        return
       end
 
       delay = entry["delay"]
@@ -111,8 +131,6 @@ module Dommy
       else
         deliver_entry(entry)
       end
-
-      nil
     end
 
     def abort
@@ -288,13 +306,36 @@ module Dommy
       dispatch_event(Event.new("readystatechange"))
     end
 
+    # A `data:` URI resolves to a synthetic 200 stub entry (see Dommy::DataUri),
+    # so XHR to an inline `data:image/svg+xml;…` works like a browser. nil for any
+    # non-data URL.
+    def data_uri_entry
+      decoded = DataUri.parse(@url)
+      return nil unless decoded
+
+      {"body" => decoded[:body], "status" => 200, "statusText" => "OK",
+       "contentType" => decoded[:content_type]}
+    end
+
     def lookup_stub
+      # Same resolution order as FetchFn: a `__fetch_handler__` callable
+      # (e.g. dommy-rack's NetworkBridge serving same-origin requests from
+      # the Rack app) gets first refusal; nil falls through to the stubs.
+      handler = @window.globals["__fetch_handler__"]
+      if handler.respond_to?(:call)
+        entry = handler.call(
+          @url,
+          {"method" => @method, "headers" => @request_headers, "body" => @request_body&.to_s}
+        )
+        return entry if entry
+      end
+
       stub_map = @window.globals["__fetchy_stub__"] ||
         @window.globals["__resource_fetch_stub__"] ||
         @window.globals["__inject_fetch_stub__"]
       return nil unless stub_map.is_a?(Hash)
 
-      stub_map[@url]
+      stub_map[@url] || stub_map[@window.__internal_url_path__(@url)]
     end
 
     # Bookkeeping that lets specs assert "fetch was called N times"

data/lib/dommy.rb

@@ -15,13 +15,24 @@ require_relative "dommy/event"
 require_relative "dommy/scheduler"
 require_relative "dommy/mutation_observer"
 require_relative "dommy/promise"
+require_relative "dommy/deferred_response"
 require_relative "dommy/blob"
 require_relative "dommy/data_transfer"
 require_relative "dommy/crypto"
 require_relative "dommy/text_codec"
 require_relative "dommy/internal/observable_callback"
+require_relative "dommy/internal/aria_role"
+require_relative "dommy/internal/accessible_name"
+require_relative "dommy/internal/accessible_description"
+require_relative "dommy/internal/aria_state"
+require_relative "dommy/internal/accessibility_tree"
+require_relative "dommy/internal/aria_snapshot"
 require_relative "dommy/internal/css_pseudo_handlers"
+require_relative "dommy/internal/css_rule_text"
+require_relative "dommy/internal/selector_ast"
 require_relative "dommy/internal/selector_parser"
+require_relative "dommy/internal/selector_index"
+require_relative "dommy/internal/selector_matcher"
 require_relative "dommy/internal/punycode"
 require_relative "dommy/internal/idna"
 require_relative "dommy/internal/ipv4_parser"
@@ -29,6 +40,7 @@ require_relative "dommy/intersection_observer"
 require_relative "dommy/resize_observer"
 require_relative "dommy/performance_observer"
 require_relative "dommy/internal/range_text_serializer"
+require_relative "dommy/internal/xml_serialization"
 require_relative "dommy/range"
 require_relative "dommy/animation"
 require_relative "dommy/bridge"
@@ -51,6 +63,7 @@ require_relative "dommy/worker"
 require_relative "dommy/location"
 require_relative "dommy/history"
 require_relative "dommy/navigator"
+require_relative "dommy/screen"
 require_relative "dommy/parser"
 require_relative "dommy/attr"
 require_relative "dommy/window"
@@ -67,6 +80,28 @@ require_relative "dommy/url"
 require_relative "dommy/form_data"
 require_relative "dommy/dom_parser"
 require_relative "dommy/css"
+require_relative "dommy/resources"
+require_relative "dommy/interaction"
+
+# JS-runtime host layer (engine-agnostic): the Runtime port + backend registry,
+# script-boot orchestration, and the standalone Browser. A concrete JS engine
+# (e.g. dommy-js-quickjs) registers itself through `Dommy::Js.register_runtime`.
+require_relative "dommy/js/runtime"
+require_relative "dommy/js/import_map"
+require_relative "dommy/js/module_loader"
+require_relative "dommy/js/script_boot"
+# Engine-agnostic JS<->Ruby DOM bridge: the marshalling core (HostBridge) and
+# its collaborators, plus the JS-side runtime bundles. A concrete backend
+# (dommy-js-quickjs) plugs an engine in underneath via the backend contract
+# documented in HostBridge.
+require_relative "dommy/js/wire_tags"
+require_relative "dommy/js/handle_table"
+require_relative "dommy/js/marshaller"
+require_relative "dommy/js/dom_interfaces"
+require_relative "dommy/js/constructor_resolver"
+require_relative "dommy/js/custom_element_bridge"
+require_relative "dommy/js/host_bridge"
+require_relative "dommy/browser"
 
 module Dommy
   # Parse an HTML string and return a fresh `Window`.
@@ -81,7 +116,7 @@ module Dommy
   def self.parse(html)
     s = html.to_s
     if s.match?(/\A\s*(<!doctype|<html\b)/i)
-      Window.new(nil, nokogiri_doc: Backend.parse(s))
+      Window.new(nil, backend_doc: Backend.parse(s))
     else
       window = Window.new
       window.document.body.inner_html = s