dommy 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52933caebd00a8d1b7dcfa14421116be45617e04d53ee6f8d8771c5fc5ccefdc
-  data.tar.gz: da2372f52dac931a6e7ad4316ec4cb15efb0effa799229eae7bde1435b8aa3c8
+  metadata.gz: 6306b86751026b1b48072c497fd34cd008c5b0bfe1838ae62ab3896d89a2aa3f
+  data.tar.gz: 817d56deed527b5f2718242937bb1a30a7d22738ca8f09276750505cf9368b5a
 SHA512:
-  metadata.gz: e05358f558f5e84fe6da7e7f705dbdc5bdd178646ef71a3ee9311a9d05893320cda1c0e6ca3596aa05e7e389e9112e96c8d44b640b7dea55480066af40e65eb7
-  data.tar.gz: ac0dea6fecd2fe7624f71cdef6f9eab786be60a584a4307d0fcac66540002de7cc1cc52812a638bfc8bb35afb53dd836ed7ebb2b007fee8fabfd172e62e8850a
+  metadata.gz: bfce9a98c80d522db534045b6ee378d0bdfb8e1f03646173e4fc74fd5e8ed46e35e723fe4ce5f7828cdab9d71b6e567c2022ad63d01f2f70af8a0baf0acd34cf
+  data.tar.gz: 6b0aa54054201df72970198f18450268d53cbe434b3da15bd9b49cd68eb98b9d94ae1acf80d40b668706052385fa8597e4580b683c472760ee970a10ee13d2f4

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

@@ -43,18 +43,6 @@ module Dommy
         node.clone_node(deep)
       end
 
-      # Makiri documents have no node-level clone; re-parsing the serialized
-      # document reproduces the full tree. Dispatch on the document kind so an XML
-      # document round-trips through the XML parser (case/namespaces/CDATA) and an
-      # HTML document through the HTML parser.
-      def clone_document(doc)
-        if doc.is_a?(::Makiri::XML::Document)
-          ::Makiri::XML::Document.parse(doc.to_xml)
-        else
-          ::Makiri::HTML::Document.parse(doc.to_html)
-        end
-      end
-
       # A fresh, empty HTML-backed document (children dropped so it starts with no
       # documentElement). The backing for a shallow clone of an HTML document.
       def empty_document
@@ -233,8 +221,8 @@ module Dommy
       end
 
       # Both Makiri document families (HTML and XML) mint a real PI node and
-      # serialize it (HTML as `<?target data>`, XML as `<?target data?>`), so PIs
-      # — unlike CDATA — need no HTML-document fallback.
+      # serialize it as `<?target data?>`, so PIs — unlike CDATA — need no
+      # HTML-document fallback.
       def create_processing_instruction(target, data, doc)
         doc.create_processing_instruction(target, data)
       end
@@ -276,6 +264,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 +324,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

@@ -53,11 +53,6 @@ module Dommy
         current.clone_node(node, deep: deep)
       end
 
-      # Deep copy of a whole document (DOM cloneNode on the document).
-      def clone_document(doc)
-        current.clone_document(doc)
-      end
-
       # A fresh, empty HTML-backed document.
       def empty_document
         current.empty_document
@@ -233,6 +228,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)
@@ -77,20 +86,23 @@ module Dommy
       promise
     end
 
-    # Walk `root`'s subtree and re-wrap any nodes whose tag is now
+    # Walk `root`'s shadow-including subtree and re-wrap any nodes whose tag is now
     # registered; fires `connectedCallback` for each upgraded node
     # that's currently attached to a document tree.
     def upgrade(root)
       return nil unless root.respond_to?(:__dommy_backend_node__)
 
-      walk_descendants(root.__dommy_backend_node__) do |nk|
-        next unless nk.element?
+      @window.document.__internal_each_shadow_including_element__(root.__dommy_backend_node__) do |nk|
         next unless @definitions.key?(nk.name)
 
-        # 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
+        wrapped = rewrap_for_upgrade(@window.document, nk)
+        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
@@ -122,6 +134,22 @@ module Dommy
       list&.each { |p| p.fulfill(klass) }
     end
 
+    # Re-wrap `nk` as its definition's class, or nil when there is nothing to
+    # upgrade. An element that is already an instance of the class is left alone:
+    # upgrading an element that is already custom does nothing. The new wrapper
+    # is told which one it replaces, because a script may hold the element — a
+    # JS-defined element upgrades that reference in place.
+    def rewrap_for_upgrade(doc, nk)
+      previous = doc.__internal_peek_wrapper__(nk)
+      klass = @definitions[nk.name]
+      return nil if klass.is_a?(Module) && previous.is_a?(klass)
+
+      doc.__internal_reset_wrapper__(nk)
+      wrapped = doc.wrap_node(nk)
+      wrapped.__internal_upgraded_from__(previous) if previous && wrapped.respond_to?(:__internal_upgraded_from__)
+      wrapped
+    end
+
     # When define() lands after the matching element is already in
     # the document, those nodes need upgrading: re-wrap them with the
     # new class and fire connectedCallback.
@@ -130,20 +158,38 @@ module Dommy
       # Match by tag name rather than interpolating `name` into a CSS selector:
       # a spec-valid custom element name may contain "." (a CSS class selector
       # char) or other metacharacters, which would corrupt the query.
-      doc.backend_doc.css("*").each do |nk|
+      # Shadow trees included, in shadow-including tree order (define step 18).
+      doc.__internal_each_shadow_including_element__(doc.backend_doc) do |nk|
         next unless nk.name == name
 
-        doc.__internal_reset_wrapper__(nk)
-        wrapped = doc.wrap_node(nk)
-        doc.__internal_notify_connected__(wrapped) if wrapped
+        wrapped = rewrap_for_upgrade(doc, nk)
+        next unless wrapped
+
+        replay_observed_attributes(wrapped)
+        doc.__internal_notify_connected__(wrapped)
       end
     end
 
-    def walk_descendants(node, &blk)
-      yield node
-      return unless node.respond_to?(:children)
-
-      node.children.each { |c| walk_descendants(c, &blk) }
+    # "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
   end
 end