dommy 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0d28c900db6681f80910f285f05e95985648e6bf824990f23d4f4b4b47bdaf9
-  data.tar.gz: 509faf8cfe617d13f1ff69507254c3ef7987d77a9bdf796fa7ce44836d63c798
+  metadata.gz: d948ccbb7ca08b92aedc5222fe46bf219060f0e2ae2903bc49b8de3401321cb2
+  data.tar.gz: 621b638bd22e4decae148605015885c49ef93b0c44f2fbadcb0d0b542b489a0d
 SHA512:
-  metadata.gz: d52a0dec8dca36a172c0ff93e89ab75126049a6b85eeea2a7527c99a162cc087b98cdf11afa7a98d0cd5024bce642ac612f955babf15a3b02af63cbddc336981
-  data.tar.gz: f8de49a82844eee7f75e5b5db13a798b7210b70a9bc1e902b85c37819fc79e98c71a2dd8d60abeeaa4f16de9a2679c15f27d48d57f7005b2345ac5a1e0fce7b5
+  metadata.gz: 89eec9a0136a58ce216bee43e800b584b42a9e41702ebf172d5f4938d937707ab8209e43ca4d5d314eee39aeefbb8c3097317aca6aba7fa6d5fee3f38c95952c
+  data.tar.gz: cac802773d9c86b06ecd2e50057741521c6bfea1d7e1f86a8cbbf520f73827207cb4b9f3bef12c19dc0e699850a042487c0704f4f6c290a7af2f53e03f50199a

data/lib/dommy/backend.rb

@@ -78,12 +78,15 @@ module Dommy
       # which matches no-quirks everywhere Dommy asks). An XML document is
       # never in it.
       def quirks_mode?(doc)
-        doc.respond_to?(:quirks_mode?) && doc.quirks_mode?
+        doc.quirks_mode?
       end
 
       # An empty backing document matching `doc`'s kind (HTML stays HTML, XML
       # stays XML) — for a shallow document clone, whose result keeps the
       # source flavor.
+      # Whether `doc` is an HTML-backed document (the HTML parser built it).
+      def html_backed?(doc) = !doc.is_a?(::Makiri::XML::Document)
+
       def empty_document_like(doc)
         doc.is_a?(::Makiri::XML::Document) ? empty_xml_document : empty_document
       end
@@ -135,21 +138,13 @@ module Dommy
       end
 
       # The DOM's createElement: an element whose local name is `local_name`
-      # as written, colons included (`foo:` and `f::oo` are valid local names,
-      # not prefixed ones), in `namespace` — the HTML namespace in an HTML or
-      # XHTML document, nil in any other. An XML document's own creator parses
-      # a QName, so its element is built from the parts. An HTML-backed one —
-      # which a document typed as XHTML or XML after an HTML parse also is —
-      # makes it by createElementNS, which keeps the name's case and the
-      # namespace given; that splits a name at its colon, and refuses `xmlns`
-      # outside the XMLNS namespace, as createElementNS must — so a name with
-      # a colon, or `xmlns`, takes the HTML document's creator, which keeps
-      # the name as written but folds it into the HTML namespace in lower case.
+      # as written, colons and case included (`foo:` and `f::oo` are valid
+      # local names, not prefixed ones), in `namespace` — the HTML namespace
+      # in an HTML or XHTML document, nil in any other. Makiri builds it from
+      # the parts in an HTML and an XML document alike, without parsing the
+      # name as a QName.
       def create_element(local_name, namespace, doc)
-        return doc.create_loose_dom_element(local_name, nil, local_name, namespace) unless doc.is_a?(::Makiri::HTML::Document)
-        return doc.create_element(local_name) if local_name.include?(":") || local_name == "xmlns"
-
-        doc.create_element_ns(namespace, local_name)
+        doc.create_loose_dom_element(local_name, nil, local_name, namespace)
       end
 
       # The DOM's createElementNS, in an HTML or an XML document alike: the
@@ -327,6 +322,12 @@ module Dommy
         node.attribute_value_ns(nil, local_name)
       end
 
+      # The qualified names of the element's attributes, in order, without
+      # materializing an attribute node for each (Element#getAttributeNames).
+      def attribute_names(node)
+        node.keys
+      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/blob.rb

@@ -43,6 +43,12 @@ module Dommy
       File.new([@data], name, {"type" => @type}, @window)
     end
 
+    # Blob's serialization + deserialization steps (structured clone): a new
+    # Blob over the same bytes and type.
+    def __internal_structured_clone__(_for_storage = false)
+      Blob.new([@data], {"type" => @type}, @window)
+    end
+
     # Return a new Blob over a byte range of this one.
     # Negative indices are treated as offsets from the end (per spec).
     def slice(start = 0, last = @size, content_type = "")
@@ -181,6 +187,12 @@ module Dommy
       @last_modified = (raw_lm || (Time.now.to_f * 1000)).to_i
     end
 
+    # File's serialization + deserialization steps: bytes, type, name and
+    # lastModified.
+    def __internal_structured_clone__(_for_storage = false)
+      File.new([@data], @name, {"type" => @type, "lastModified" => @last_modified}, @window)
+    end
+
     def __js_get__(key)
       case key
       when "name"
@@ -210,6 +222,11 @@ module Dommy
 
     alias size length
 
+    # FileList's serialization + deserialization steps: each File cloned.
+    def __internal_structured_clone__(for_storage = false)
+      FileList.new(@files.map { |file| file.__internal_structured_clone__(for_storage) })
+    end
+
     def item(index)
       @files[index.to_i]
     end

data/lib/dommy/bridge/values.rb

@@ -3,8 +3,8 @@
 module Dommy
   module Bridge
     # The Ruby shapes a JS value takes while it is on this side: an opaque
-    # reference, and the two byte buffers that cross as a typed array or a bare
-    # ArrayBuffer.
+    # reference (a Date one carrying its time value), and the two byte buffers
+    # that cross as a typed array or a bare ArrayBuffer.
 
     # An opaque handle to a JS-side value that Ruby only stores and hands back
     # (an AbortSignal's reason, a CustomEvent's detail). A non-plain JS object
@@ -35,6 +35,33 @@ module Dommy
       def inspect = "#<Dommy::Bridge::JSValue #{to_s}>"
     end
 
+    # A JS Date that crossed into Ruby. It is still an opaque reference, so
+    # handing it back returns the same Date, but it also carries its time value
+    # (ms since the epoch, NaN for an invalid date) — the one thing a host API
+    # taking a Date (`input.valueAsDate = d`) needs to read off it. A Date the
+    # host creates crosses from a Ruby ::Time instead.
+    class Date < JSValue
+      # The largest time value a JS Date can hold, either side of the epoch.
+      MAX_TIME_VALUE = 8_640_000_000_000_000
+
+      # The time value a JS Date made from `time` holds — ECMAScript's TimeClip:
+      # whole milliseconds truncated toward zero (0.1 ms before the epoch is 0,
+      # not -1), and NaN beyond MAX_TIME_VALUE.
+      def self.time_value_of(time)
+        ms = (time.to_r * 1000).truncate
+        ms.abs > MAX_TIME_VALUE ? ::Float::NAN : ms.to_f
+      end
+
+      attr_reader :time_value
+
+      def initialize(ref, time_value)
+        super(ref, nil, nil, "Date")
+        @time_value = time_value
+      end
+
+      def inspect = "#<Dommy::Bridge::Date #{time_value}>"
+    end
+
     # A byte buffer that crosses the JS boundary as a `Uint8Array` (rather than a
     # plain Array). Wrap a host method's byte-array result in this so JS sees a
     # real typed array — e.g. `TextEncoder#encode`, `Blob#arrayBuffer`. The

data/lib/dommy/bridge/wire_tags.rb

@@ -25,10 +25,6 @@ module Dommy
       # method set) instead of a `__rb_host_describe` round trip per new proxy —
       # the dominant overhead when JS traverses/builds many nodes.
       INTERFACE = "__rb_if"
-      # The custom-element tag of a handle whose node is a registered custom
-      # element (so makeProxy upgrades it), carried per-instance since it is the
-      # one part of a describe that is NOT per-interface.
-      CUSTOM_ELEMENT = "__rb_ce"
       # A live JS function that crossed into Ruby, referenced by callback id.
       CALLBACK = "__rb_callback"
       # An opaque JS value referenced by its id in the JS-side `jsRefs` table
@@ -58,6 +54,10 @@ module Dommy
       BYTES = "__rb_bytes"
       # A byte buffer crossing as a bare JS ArrayBuffer.
       ARRAY_BUFFER = "__rb_arraybuffer"
+      # A JS Date's time value (ms since the epoch). Host -> JS it builds a new
+      # Date; JS -> host it decorates a JS_REF, so the Date keeps its identity
+      # and the host can still read the time (see Dommy::Bridge::Date).
+      DATE = "__rb_date"
       # A host-raised DOMException/TypeError/RangeError, re-thrown JS-side.
       EXCEPTION = "__rb_exception__"
       # A host-created native JS error (TypeError/RangeError) crossing as a VALUE
@@ -68,6 +68,10 @@ module Dommy
       THROW = "__rb_throw__"
       # A callback whose JS invocation threw (the thrown value is carried here).
       CALLBACK_THREW = "__rb_cb_threw__"
+      # A structured-serialization record the JS realm holds (by id), crossing
+      # as an opaque Dommy::Js::SerializedRecord (see host_runtime.js
+      # serializedTag).
+      SERIALIZED = "__rb_serialized"
     end
   end
 end