dommy 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52933caebd00a8d1b7dcfa14421116be45617e04d53ee6f8d8771c5fc5ccefdc
-  data.tar.gz: da2372f52dac931a6e7ad4316ec4cb15efb0effa799229eae7bde1435b8aa3c8
+  metadata.gz: 47c59ce209a6e63313db2b6685126910463abfc26020ec5f24a7b7494b67b10f
+  data.tar.gz: 43980f4f5eb7b2c5bfe76e41bd2786e9c8cad571df1eb882e0e6d5107fbe04c6
 SHA512:
-  metadata.gz: e05358f558f5e84fe6da7e7f705dbdc5bdd178646ef71a3ee9311a9d05893320cda1c0e6ca3596aa05e7e389e9112e96c8d44b640b7dea55480066af40e65eb7
-  data.tar.gz: ac0dea6fecd2fe7624f71cdef6f9eab786be60a584a4307d0fcac66540002de7cc1cc52812a638bfc8bb35afb53dd836ed7ebb2b007fee8fabfd172e62e8850a
+  metadata.gz: b2627fa8969554f7ecb7a04ed16c331a77e604b44a9ca9e95412a89e48412744a3dd606892255e93eb56988cfda5214000a15821bbc5eb6ed7d18701740b3262
+  data.tar.gz: 632bddbea02093111566d46ba9fc44af35ed17879bf9921c4ad477a138d44b83e2c2761337d34f5bdfa31cc150353a4b7afe47b0cca8d817e79eda95d7b556ad

data/lib/dommy/attr.rb

@@ -71,11 +71,10 @@ module Dommy
 
     def value
       if @owner
-        if @namespace_uri
-          Backend.get_attribute_ns(@owner.__dommy_backend_node__, @namespace_uri, @local_name).to_s
-        else
-          @owner.__dommy_backend_node__[@name].to_s
-        end
+        # Both branches go through the namespace-aware read: the backend's
+        # `node[name]` indexes by local name, so a null-namespace `b` would read
+        # back the value of a prefixed `xml:b` sitting on the same element.
+        Backend.get_attribute_ns(@owner.__dommy_backend_node__, @namespace_uri, @local_name).to_s
       else
         @detached_value
       end

data/lib/dommy/backend/makiri_adapter.rb

@@ -276,6 +276,12 @@ module Dommy
 
         node["xmlns:#{prefix}"] = href.to_s
         nil
+      rescue ArgumentError
+        # DOM validates a qualified name against the Name production, which
+        # admits prefixes an XML backend cannot spell as an `xmlns:` attribute
+        # ("0:a", ";:a"). The element is still valid — its prefix and namespace
+        # live on the wrapper — so the declaration is simply not written.
+        nil
       end
 
       def namespace_definitions(_node)
@@ -330,6 +336,22 @@ module Dommy
         node.attribute_nodes
       end
 
+      # Attribute node matching the qualified name exactly. `node[name]` would
+      # also answer for a prefixed attribute with that local name.
+      #
+      # This sits under `getAttribute` / `hasAttribute` / `setAttribute` /
+      # `removeAttribute`, so it runs on the hottest path in the library — every
+      # CSS match, every reflected IDL attribute — and Makiri does the scan
+      # natively (0.9.0). The value-returning spelling is what the two readers
+      # that only want the value ask for: it wraps no Attr at all.
+      def attr_by_qualified_name(node, qualified_name)
+        node.attribute_by_qualified_name(qualified_name.to_s)
+      end
+
+      def attr_value_by_qualified_name(node, qualified_name)
+        node.attribute_value_by_qualified_name(qualified_name.to_s)
+      end
+
       # Attribute node matching (namespace, local name) case-sensitively; a
       # null/empty namespace matches a null-namespace attribute.
       def attr_by_ns(node, namespace, local_name)

data/lib/dommy/backend.rb

@@ -233,6 +233,24 @@ module Dommy
         current.attribute_ns_info(attr_node)
       end
 
+      # The attribute node whose QUALIFIED name is `qualified_name`, or nil.
+      #
+      # WHATWG's by-name family ("get an attribute by name", `setAttribute`,
+      # `removeAttribute`) matches on the qualified name. A lookup by local name
+      # confuses `b` with a prefixed `xml:b`, so those paths must come through
+      # here rather than through `node[name]`.
+      def attr_by_qualified_name(node, qualified_name)
+        current.attr_by_qualified_name(node, qualified_name)
+      end
+
+      # That attribute's VALUE, or nil when there is no such attribute. The same
+      # match without an attribute node in hand, for the two readers that only
+      # ever wanted the value — `getAttribute` and `hasAttribute` — which run on
+      # every CSS match and every reflected IDL attribute.
+      def attr_value_by_qualified_name(node, qualified_name)
+        current.attr_value_by_qualified_name(node, qualified_name)
+      end
+
       # The element's attribute nodes (each readable via attribute_ns_info).
       # The single choke point so DOM code doesn't touch parser internals.
       def attribute_nodes(node)

data/lib/dommy/browser.rb

@@ -279,9 +279,16 @@ module Dommy
       runtime.install_wasm_memory_shim if @wasm_memory_shim && runtime.respond_to?(:install_wasm_memory_shim)
       window.globals["__fetch_handler__"] = Resources::FetchHandler.new(@resources) if @resources
       @runtime = runtime
+      doc = window.document
+      # An `on*` attribute that arrived after boot (a cloned template, an
+      # innerHTML fragment) is compiled on first dispatch, which replays the scan.
+      # Installed whenever a runtime is attached — an embedder that drives script
+      # boot itself (`execute_scripts: false`) still needs inline handlers wired.
+      doc.inline_handler_wirer = lambda do
+        Js::ScriptBoot.wire_inline_handlers(runtime, on_error: ->(e) { @js_errors << e })
+      end
       return unless @execute_scripts
 
-      doc = window.document
       # Dynamically-inserted `<script src>` (webpack/Vite on-demand chunks)
       # fetch + run through the same resources adapter, after boot.
       doc.external_script_runner = lambda do |element, src|

data/lib/dommy/callable_invoker.rb

@@ -25,15 +25,23 @@ module Dommy
     # that order). A JS function listener's `this` must be the event's
     # currentTarget (the node the listener is attached to), so pass it through
     # when the bridge supports an explicit receiver.
-    def invoke_listener(listener, event, current_target = nil)
+    # `args:` overrides the single-event argument list — the special error
+    # event handler (`window.onerror`) is called with (message, filename,
+    # lineno, colno, error) instead of the event. An EventListener object's
+    # handleEvent always receives the event.
+    def invoke_listener(listener, event, current_target = nil, args: nil)
+      args ||= [event]
       if listener.respond_to?(:handle_event)
         listener.handle_event(event)
       elsif listener.respond_to?(:call) && !listener.is_a?(Module)
-        listener.call(event)
-      elsif listener.respond_to?(:__js_call_with_this__)
-        listener.__js_call_with_this__([event], current_target)
+        listener.call(*args)
+      elsif listener.respond_to?(:__js_invoke__)
+        # A JS function listener: `this` is the currentTarget, and a thrown value
+        # surfaces (as a ThrowValue) so the dispatch reports it as a window
+        # `error` event instead of swallowing it.
+        listener.__js_invoke__(args, this: current_target, raising: true)
       elsif listener.respond_to?(:__js_call__)
-        listener.__js_call__("call", [event])
+        listener.__js_call__("call", args)
       end
     end
   end

data/lib/dommy/css.rb

@@ -18,7 +18,9 @@ module Dommy
   class CSSStyleSheet
     attr_reader :owner_node, :css_rules
 
-    def initialize(owner_node:, href: nil, media: nil, title: nil, type: "text/css", source_text: nil)
+    # A stylesheet constructed by `new CSSStyleSheet()` has no owner node.
+    # Element-owned sheets still pass their <style> / <link> node explicitly.
+    def initialize(owner_node: nil, href: nil, media: nil, title: nil, type: "text/css", source_text: nil)
       @owner_node = owner_node
       @href = href
       @media = media
@@ -291,21 +293,27 @@ module Dommy
     end
 
     def get_property_value(name)
-      entry = @props[name.to_s]
+      entry = @props[property_key(name)]
       entry ? entry[:value] : ""
     end
 
     def get_property_priority(name)
-      entry = @props[name.to_s]
+      entry = @props[property_key(name)]
       entry ? entry[:priority] : ""
     end
 
     def set_property(name, value, priority = nil)
-      key = name.to_s
+      key = property_key(name)
       if value.nil? || value.to_s.empty?
+        # CSSOM step 3 — an empty value removes the declaration, and it runs
+        # before the priority check, so the priority is irrelevant here.
         @props.delete(key)
       else
-        important = priority.to_s.downcase == "important" ? "important" : ""
+        # CSSOM step 4 — an invalid priority abandons the call, leaving the
+        # declaration block exactly as it was.
+        important = Internal::CssPriority.normalize(priority)
+        return nil if important.nil?
+
         @props[key] = {value: value.to_s, priority: important}
       end
       flush!
@@ -313,7 +321,7 @@ module Dommy
     end
 
     def remove_property(name)
-      removed = @props.delete(name.to_s)
+      removed = @props.delete(property_key(name))
       flush!
       removed ? removed[:value] : ""
     end
@@ -403,6 +411,13 @@ module Dommy
 
     private
 
+    # CSSOM normalizes every property name it is handed (see
+    # Internal::CSS::Parser.property_name); `css_name` below is the separate
+    # camelCase / snake_case → kebab conversion for the IDL accessors.
+    def property_key(name)
+      Internal::CSS::Parser.property_name(name)
+    end
+
     def css_name(name)
       str = name.to_s
       return str if str.start_with?("--")
@@ -414,8 +429,8 @@ module Dommy
     # reusing the cascade's declaration parser (same normalization the cascade
     # sees) so reads agree with computed style.
     def parse(body_text)
-      Internal::CSS::Parser.parse_declarations(body_text.to_s).each_with_object({}) do |decl, out|
-        out[decl.name] = {value: decl.value, priority: decl.important ? "important" : ""}
+      Internal::CSS::Parser.parse_block(body_text).transform_values do |decl|
+        {value: decl.value, priority: decl.important ? "important" : ""}
       end
     end
 
@@ -458,8 +473,16 @@ module Dommy
       @parent_style_sheet = parent_style_sheet
     end
 
+    # CSSOM serializes a style rule as its selector plus its declaration block,
+    # so the text is rebuilt from the parsed declarations rather than echoed
+    # back: `#foo { color: red }` reads as `#foo { color: red; }`, and a block
+    # whose contents are not declarations at all serializes empty. An at-rule
+    # keeps its text as given.
     def css_text
-      @css_text
+      return @css_text unless style_rule?
+
+      declarations = style&.css_text.to_s
+      declarations.empty? ? "#{selector_text} { }" : "#{selector_text} { #{declarations} }"
     end
 
     def css_text=(v)
@@ -553,7 +576,7 @@ module Dommy
 
     def __js_get__(key)
       case key
-      when "cssText" then @css_text
+      when "cssText" then css_text
       when "type" then type
       when "selectorText" then selector_text
       when "style" then style

data/lib/dommy/custom_elements.rb

@@ -34,6 +34,15 @@ module Dommy
       @pending_promises = {}
     end
 
+    # Whether `name` is a valid custom element name. Also consulted by
+    # `element_class_for`: an unrecognized HTML-namespace name that is valid here
+    # is an *undefined custom element* (interface HTMLElement), not an unknown
+    # element (HTMLUnknownElement).
+    def self.valid_name?(name)
+      key = name.to_s
+      key.match?(NAME_RE) && !RESERVED_NAMES.include?(key)
+    end
+
     def define(name, klass, _options = nil)
       key = name.to_s
       unless key.match?(NAME_RE)
@@ -90,7 +99,13 @@ module Dommy
         # Force re-wrap by clearing the document's cached wrapper.
         @window.document.__internal_reset_wrapper__(nk)
         wrapped = @window.document.wrap_node(nk)
-        @window.document.__internal_notify_connected__(wrapped) if wrapped
+        next unless wrapped
+
+        replay_observed_attributes(wrapped)
+        # connectedCallback is enqueued only for an element that is actually in
+        # a document tree — `customElements.upgrade()` on a detached subtree
+        # upgrades it without connecting it.
+        @window.document.__internal_notify_connected__(wrapped) if wrapped.is_connected?
       end
 
       nil
@@ -135,7 +150,32 @@ module Dommy
 
         doc.__internal_reset_wrapper__(nk)
         wrapped = doc.wrap_node(nk)
-        doc.__internal_notify_connected__(wrapped) if wrapped
+        next unless wrapped
+
+        replay_observed_attributes(wrapped)
+        doc.__internal_notify_connected__(wrapped)
+      end
+    end
+
+    # "Upgrade an element" step 6: the element's *existing* attributes are
+    # replayed through attributeChangedCallback (oldValue null) before
+    # connectedCallback, so a definition registered after the markup was parsed
+    # still sees the attributes that were already there.
+    def replay_observed_attributes(element)
+      klass = element.class
+      return unless klass.respond_to?(:observed_attributes)
+
+      observed = Array(klass.observed_attributes).map { |a| a.to_s.downcase }
+      return if observed.empty?
+
+      element.get_attribute_names.each do |name|
+        next unless observed.include?(name.to_s.downcase)
+
+        # Routed through the coordinator so the callback's arity handling (the
+        # optional 4th namespace argument) stays in one place.
+        @window.document.__internal_notify_attribute_changed__(
+          element, name, nil, element.get_attribute(name)
+        )
       end
     end