dommy 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d948ccbb7ca08b92aedc5222fe46bf219060f0e2ae2903bc49b8de3401321cb2
-  data.tar.gz: 621b638bd22e4decae148605015885c49ef93b0c44f2fbadcb0d0b542b489a0d
+  metadata.gz: 2063a6335f55bcddf4a9db6b162b0ea69ccce3aaa4c8b7bd45069850992c98ca
+  data.tar.gz: 725b6c8395b377fcddbda372ecb55709f169e0143b5a0bc404f78036db18e243
 SHA512:
-  metadata.gz: 89eec9a0136a58ce216bee43e800b584b42a9e41702ebf172d5f4938d937707ab8209e43ca4d5d314eee39aeefbb8c3097317aca6aba7fa6d5fee3f38c95952c
-  data.tar.gz: cac802773d9c86b06ecd2e50057741521c6bfea1d7e1f86a8cbbf520f73827207cb4b9f3bef12c19dc0e699850a042487c0704f4f6c290a7af2f53e03f50199a
+  metadata.gz: 7a4af1e30b2e3efe5de479b05c67d770e7ca6e11b71db0fc932c5ba382cee6e52a65ebebfb63be3aa2ac8e431efec5e1da9f97fcbc85fd3fea7e12926b3f4350
+  data.tar.gz: 0dab9637f563f76636614616d79b2422e618ac92aff8cc39a5b8f3c64730ee1af68b48f09b76b37d5b9c2b85bcd38131549863862ee598f4c5b7b0b0d449b42e

data/lib/dommy/animation.rb

@@ -88,6 +88,7 @@ module Dommy
   # Spec: https://drafts.csswg.org/web-animations/#animation
   class Animation
     include EventTarget
+    include Internal::WindowBound
 
     attr_accessor :id
     attr_reader :effect, :timeline, :play_state

data/lib/dommy/backend.rb

@@ -91,6 +91,9 @@ module Dommy
         doc.is_a?(::Makiri::XML::Document) ? empty_xml_document : empty_document
       end
 
+      # Whether backend node `node` belongs to an XML document's tree.
+      def xml_node?(node) = node.is_a?(::Makiri::XML::NodeMethods)
+
       # Bring `node` (already detached from its old tree) into `target_doc`,
       # returning the backend node now owned by `target_doc`. Lexbor's arenas
       # can't move a node between documents, so adoption imports a detached

data/lib/dommy/blob.rb

@@ -187,6 +187,12 @@ module Dommy
       @last_modified = (raw_lm || (Time.now.to_f * 1000)).to_i
     end
 
+    # A File under another name keeps its lastModified (XHR's "create an
+    # entry"); only a Blob gets a new one.
+    def __internal_file_named__(name)
+      File.new([@data], name, {"type" => @type, "lastModified" => @last_modified}, @window)
+    end
+
     # File's serialization + deserialization steps: bytes, type, name and
     # lastModified.
     def __internal_structured_clone__(_for_storage = false)

data/lib/dommy/browser.rb

@@ -58,8 +58,11 @@ module Dommy
       browser
     end
 
+    # `encoding` is the encoding the page's bytes were decoded with
+    # (Encodings.decode_document), when it came from bytes; HTML given as a
+    # string makes a UTF-8 document.
     def initialize(html, url: "http://localhost/", resources: nil, execute_scripts: true, strict: true, settle: true,
-      wasm_memory_shim: false, backend: nil, navigable: false, same_origin: false)
+      wasm_memory_shim: false, backend: nil, navigable: false, same_origin: false, encoding: nil)
       @resources = resources
       @same_origin = same_origin
       @backend = backend
@@ -81,7 +84,7 @@ module Dommy
       @cookie_jar = CookieJar.new
       @before_unload_handler = nil
 
-      @window = Dommy.parse(html)
+      @window = Dommy.parse(html, encoding: encoding)
       @window.location.__internal_set_url__(url) if url
       @window.storage_provider = @storage_provider
       @window.cookie_jar = @cookie_jar
@@ -558,7 +561,12 @@ module Dommy
       fire_unload(old_window)
       check_js_errors!
 
-      new_window = Dommy.parse(Encodings.decode_document(response.body, response_header(response, "content-type")))
+      # HTML's <meta charset> prescan is for an HTML document (one that names
+      # no type is taken for one); an XML type's encoding is not a <meta>'s.
+      content_type = response_header(response, "content-type")
+      type = Internal::MimeType.essence(content_type)
+      text, encoding = Encodings.decode_document(response.body, content_type, html: type.empty? || type == "text/html")
+      new_window = Dommy.parse(text, encoding: encoding)
       new_window.location.__internal_set_url__(final_url)
       new_window.document.__internal_set_last_modified__(response_header(response, "last-modified"))
       new_window.document.__internal_referrer__ = referrer if referrer
@@ -763,7 +771,7 @@ module Dommy
       document = window.document
       window.dispatch_event(document.__internal_page_transition_event__("pagehide"))
       unload = Dommy::Event.new("unload")
-      unload.__internal_set_target__(document)
+      unload.__internal_set_legacy_target_override__(document)
       window.dispatch_event(unload.__internal_mark_trusted__)
     end
 

data/lib/dommy/character_data.rb

@@ -269,19 +269,7 @@ module Dommy
     # no `slot` attribute, so it targets the default (unnamed) slot of its parent
     # element's shadow tree; a closed shadow tree hides the assignment (null).
     def assigned_slot
-      parent = @__node__.parent
-      return nil unless parent&.element?
-
-      host = @document.wrap_node(parent)
-      return nil unless host.respond_to?(:shadow_root)
-
-      sr = host.shadow_root
-      return nil unless sr
-      return nil if sr.__js_get__("mode") == "closed"
-
-      sr.query_selector_all("slot").find do |slot|
-        (slot.respond_to?(:name) ? slot.name.to_s : "") == ""
-      end
+      Internal::SlotAssignment.find_slot(@document, @__node__, open: true)
     end
 
     def __js_set__(key, value)

data/lib/dommy/cookie_store.rb

@@ -10,6 +10,7 @@ module Dommy
   # Spec: https://cookiestore.spec.whatwg.org/
   class CookieStore
     include EventTarget
+    include Internal::WindowBound
 
     def initialize(window)
       @window = window
@@ -95,7 +96,7 @@ module Dommy
       opts = arg.transform_keys(&:to_s)
       url = document_url
       if opts["url"]
-        parsed = @window.__internal_parse_url__(opts["url"].to_s)
+        parsed = @window.__internal_parse_url__(opts["url"].to_s, utf8: true)
         raise Bridge::TypeError, "invalid url" unless parsed && Internal::Origin.of_url(parsed) == @window.origin
 
         url = parsed

data/lib/dommy/document.rb

@@ -693,12 +693,18 @@ module Dommy
       @quirks_mode = value
     end
 
-    # The document's character encoding, as an Encoding Standard name. Dommy
-    # holds the DOM as UTF-8 and models no other encoding; this is the one place
-    # HTML's "encoding-parse a URL" reads it from (see Element#resolve_url), so a
-    # future non-UTF-8 document has a single place to teach.
+    # The document's character encoding, as an Encoding Standard name: what
+    # its bytes were decoded with (Encodings.decode_document, which reads a
+    # `<meta charset>` from an HTML document's bytes); a document parsed from a
+    # string, which is text already, is UTF-8. The DOM is held as UTF-8
+    # either way; the encoding is what HTML's "encoding-parse a URL" (a link's
+    # query) and form submission encode with.
     def character_encoding
-      "UTF-8"
+      @character_encoding || "UTF-8"
+    end
+
+    def __internal_character_encoding__=(name)
+      @character_encoding = name
     end
 
     # ----- Public Ruby API (snake_case) -----
@@ -845,6 +851,13 @@ module Dommy
       @creator_url || "about:blank"
     end
 
+    # The window whose event loop runs this document's tasks and microtasks:
+    # its own, or for a document with none, the window of the document whose
+    # API made it.
+    def __internal_event_loop_window__
+      @default_view || @origin_document&.__internal_event_loop_window__
+    end
+
     # A document made by a parsing or creation API (DOMParser,
     # DOMImplementation) takes its origin from `document` — the relevant
     # global object's associated Document — and, for DOMParser, its URL too.
@@ -1092,41 +1105,28 @@ module Dommy
     # wrapper is owned by `this`. Per spec, the source node is left
     # in place. `deep: true` copies the entire subtree.
     def import_node(node, deep = false)
+      # WebIDL converts `options` before the method steps run, so a bad
+      # customElementRegistry is a TypeError whatever `node` is — an Attr, or
+      # even a Document.
+      deep, registry = import_node_options(deep)
+
       # Step 1: "If node is a document or shadow root, throw a
       # NotSupportedError." Neither has anywhere to go in another document.
       if node.is_a?(Document) || node.is_a?(ShadowRoot)
         raise DOMException::NotSupportedError, "a #{node.is_a?(Document) ? "document" : "shadow root"} cannot be imported"
       end
 
+      # Step 5.3: a global registry stands only for its own document.
+      if registry && !registry.scoped? && !registry.equal?(__internal_custom_element_registry__)
+        raise DOMException::NotSupportedError, "a global registry other than the document's"
+      end
+
       # An Attr is a Node but not a backend-tree node: it is copied by rebuilding
       # it here with the same qualified name, namespace, prefix and value, owned
       # by no element (importNode never attaches the copy to anything).
       return import_attribute(node) if node.is_a?(Attr)
       return nil unless node.is_a?(Node) && node.__dommy_backend_node__
 
-      # `(boolean or ImportNodeOptions) options = false`: missing or undefined
-      # is the default, false. Null and an object convert to the dictionary,
-      # whose `selfOnly` negates `deep` (so null clones deep) and whose
-      # `customElementRegistry` (a scoped one, or this document's) is the
-      # registry the copies fall back to. Anything else is a boolean, read
-      # with ToBoolean.
-      registry = nil
-      deep = false if deep.equal?(Bridge::UNDEFINED)
-      if deep.nil? || deep.is_a?(Hash)
-        options = deep || {}
-        deep = !Internal::WebIDL.boolean(options["selfOnly"])
-        given = options.fetch("customElementRegistry", Bridge::UNDEFINED)
-        unless given.equal?(Bridge::UNDEFINED)
-          raise Bridge::TypeError, "customElementRegistry is not a CustomElementRegistry" unless given.is_a?(CustomElementRegistry)
-          if !given.scoped? && !given.equal?(__internal_custom_element_registry__)
-            raise DOMException::NotSupportedError, "a global registry other than the document's"
-          end
-
-          registry = given
-        end
-      else
-        deep = Internal::WebIDL.boolean(deep)
-      end
       # "Clone a single node": the node's own registry — a global one standing
       # for this document's — and the fallback only for a node without one.
       fallback = registry || __internal_custom_element_registry__
@@ -2530,7 +2530,7 @@ module Dommy
       view = @default_view
       if view
         load = Event.new("load")
-        load.__internal_set_target__(self)
+        load.__internal_set_legacy_target_override__(self)
         view.dispatch_event(load.__internal_mark_trusted__)
         view.dispatch_event(__internal_page_transition_event__("pageshow"))
       end
@@ -2569,7 +2569,7 @@ module Dommy
     # back/forward cache), targeted at the document (legacy target override).
     def __internal_page_transition_event__(type, persisted: false)
       event = PageTransitionEvent.new(type, "persisted" => persisted, "bubbles" => true, "cancelable" => true)
-      event.__internal_set_target__(self)
+      event.__internal_set_legacy_target_override__(self)
       event.__internal_mark_trusted__
     end
 
@@ -2635,6 +2635,7 @@ module Dommy
         script.__internal_mark_parser_document__
       end
       parsed_css("meta[http-equiv]").each { |node| __internal_html_element_wrapper__(node)&.__internal_run_pragma__ }
+      parsed_css("meta[name][content]").each { |node| __internal_html_element_wrapper__(node)&.__internal_run_referrer_metadata__ }
       # An open dialog the parser inserted runs its dialog setup steps.
       parsed_css("dialog[open]").each do |node|
         dialog = __internal_html_element_wrapper__(node)
@@ -2667,6 +2668,12 @@ module Dommy
     # content=…>`): nil until such a pragma has been processed.
     attr_accessor :__internal_pragma_default_language__
 
+    # The document's referrer policy as `<meta name=referrer>` sets it
+    # (HTMLMetaElement#__internal_run_referrer_metadata__): "" (the default)
+    # until one does.
+    def __internal_referrer_policy__ = @__internal_referrer_policy__ || ""
+    attr_writer :__internal_referrer_policy__
+
     # DOMParser parses with scripting disabled (HTML) or XML scripting support
     # disabled, so every script it makes is "already started": moved or cloned
     # into a document that runs scripts, it still does not run. Found by local
@@ -2730,6 +2737,10 @@ module Dommy
     # node back to its shadow boundary.
     # Delegate to ShadowRootRegistry
 
+    def __internal_unregister_shadow_root__(fragment_node, host_node)
+      @shadow_registry.unregister(fragment_node, host_node)
+    end
+
     def __internal_register_shadow_fragment__(fragment_node, shadow_root)
       @shadow_registry.register(fragment_node, shadow_root)
     end
@@ -2820,12 +2831,20 @@ module Dommy
       @shadow_registry.find_enclosing(node)
     end
 
+    # Whether any shadow root is attached in this document.
+    def __internal_any_shadow_roots__ = @shadow_registry.any?
+
     # Every ShadowRoot attached in this document — the cascade collects each
     # one's <style> sheets and scopes them to that shadow tree.
     def __internal_all_shadow_roots__
       @shadow_registry.all
     end
 
+    # The slots whose slotchange is pending (DOM "signal slots").
+    def __internal_slot_signals__
+      @slot_signals ||= Internal::SlotSignals.new(self)
+    end
+
     # Lifecycle callback dispatchers. Errors raised inside user
     # callbacks are swallowed so a single buggy custom element can't
     # break the whole mutation pipeline.
@@ -3423,6 +3442,24 @@ module Dommy
 
     private
 
+    # `(boolean or ImportNodeOptions) options = false`, as [deep, registry]:
+    # missing or undefined is the default, false. Null and an object convert
+    # to the dictionary, whose `selfOnly` negates `deep` (so null clones deep)
+    # and whose `customElementRegistry` has to be a CustomElementRegistry.
+    # Anything else is a boolean, read with ToBoolean.
+    def import_node_options(options)
+      return [false, nil] if options.equal?(Bridge::UNDEFINED)
+      return [Internal::WebIDL.boolean(options), nil] unless options.nil? || options.is_a?(Hash)
+
+      options ||= {}
+      deep = !Internal::WebIDL.boolean(options["selfOnly"])
+      registry = options.fetch("customElementRegistry", Bridge::UNDEFINED)
+      return [deep, nil] if registry.equal?(Bridge::UNDEFINED)
+      raise Bridge::TypeError, "customElementRegistry is not a CustomElementRegistry" unless registry.is_a?(CustomElementRegistry)
+
+      [deep, registry]
+    end
+
     # HTML "is a registrable domain suffix of or is equal to" (a single label
     # stands in for the public suffix; see #domain=).
     def registrable_domain_suffix_or_equal?(suffix_string, original_host)

data/lib/dommy/element.rb

@@ -1398,6 +1398,17 @@ module Dommy
       Backend.no_namespace_attribute_value(@__node__, local_name)
     end
 
+    # An ARIA attribute (`role`, `aria-*`) as accessibility reads it: the
+    # content attribute, else a custom element's default ARIA semantics from
+    # its ElementInternals (ARIA §"default implicit ARIA semantics").
+    def __internal_aria_value__(attr)
+      value = __internal_attribute_value__(attr)
+      return value unless value.nil?
+
+      internals = __internal_element_internals__ if respond_to?(:__internal_element_internals__)
+      internals&.__internal_default_aria__(attr)
+    end
+
     # HTML's cloning steps, for the state an element keeps beside its
     # attributes: what a copy takes over, as a Hash, or nil when there is
     # nothing. Each interface and mixin with such state adds its own to what

data/lib/dommy/element_internals.rb

@@ -35,6 +35,18 @@ module Dommy
       @validity = nil
     end
 
+    # The element's default ARIA value for content attribute `attr` ("role",
+    # "aria-label"), as set through these internals; nil when unset.
+    def __internal_default_aria__(attr)
+      value = @aria[ARIA_IDL_BY_ATTRIBUTE[attr]]
+      value&.to_s
+    end
+
+    ARIA_IDL_BY_ATTRIBUTE = Internal::IdlReflection::TABLE.fetch("Element")
+                                                          .select { |name, _| ARIA_ATTRIBUTES.include?(name) }
+                                                          .to_h { |name, spec| [spec[:attr] || name, name] }.freeze
+    private_constant :ARIA_IDL_BY_ATTRIBUTE
+
     # Whether the custom state `name` is set (`:state(name)`).
     def state?(name) = @states.include?(name)