dommy 0.5.0 → 0.7.0

data/lib/dommy/event.rb

@@ -54,24 +54,30 @@ module Dommy
       # Per spec, dispatchEvent must receive an Event instance.
       raise TypeError, "dispatchEvent requires an Event, got #{event.class}" unless event.is_a?(Event)
 
-      event.__prepare_for_dispatch__(self)
+      event.__internal_prepare_for_dispatch__(self)
       path = if event.bubbles?
         event.__js_get__("composed") ? composed_bubble_path(event) : event_bubble_path
       else
         [self]
       end
 
-      event.__record_path__(path) if event.respond_to?(:__record_path__)
+      event.__internal_record_path__(path) if event.respond_to?(:__internal_record_path__)
       path.each do |target|
-        event.__set_current_target__(target)
-        target.__deliver_event__(event)
+        event.__internal_set_current_target__(target)
+        target.__internal_deliver_event__(event)
         break if event.propagation_stopped?
       end
 
+      # WHATWG: after dispatch completes, currentTarget reverts to
+      # null and eventPhase reverts to NONE. Dommy derives
+      # eventPhase from currentTarget, so clearing it here covers
+      # both spec requirements.
+      event.__internal_set_current_target__(nil)
+
       !event.default_prevented?
     end
 
-    def __deliver_event__(event)
+    def __internal_deliver_event__(event)
       listeners = listeners_for(event.type).dup
       listeners.each do |entry|
         invoke_listener(entry.listener, event)
@@ -106,7 +112,7 @@ module Dommy
     def event_bubble_path
       path = [self]
       current = self
-      while (current = current.send(:__event_parent__))
+      while (current = current.send(:__internal_event_parent__))
         path << current
       end
 
@@ -116,12 +122,12 @@ module Dommy
     # Build the propagation path with optional shadow-boundary
     # crossing. When the in-flight event has `composed: true`, the
     # walk continues from a ShadowRoot to its host; otherwise it
-    # stops at the shadow boundary (nil from `__event_parent__`).
+    # stops at the shadow boundary (nil from `__internal_event_parent__`).
     def composed_bubble_path(event)
       path = [self]
       current = self
       loop do
-        nxt = current.send(:__event_parent__)
+        nxt = current.send(:__internal_event_parent__)
         if nxt.nil? && event.respond_to?(:__js_get__) && event.__js_get__("composed")
           # Try to cross a shadow boundary
           if current.is_a?(ShadowRoot)
@@ -148,12 +154,12 @@ module Dommy
     private
 
     def enclosing_shadow_root_of(target)
-      return nil unless target.respond_to?(:__node__)
+      return nil unless target.respond_to?(:__dommy_backend_node__)
 
       doc = target.instance_variable_get(:@document)
-      return nil unless doc && doc.respond_to?(:__shadow_root_containing__)
+      return nil unless doc && doc.respond_to?(:__internal_shadow_root_containing__)
 
-      doc.__shadow_root_containing__(target.__node__)
+      doc.__internal_shadow_root_containing__(target.__dommy_backend_node__)
     end
 
     public
@@ -178,6 +184,12 @@ module Dommy
   class StandaloneEventTarget
     include EventTarget
 
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    JS_METHOD_NAMES = %w[addEventListener removeEventListener dispatchEvent].freeze
+    def __js_method_names__
+      JS_METHOD_NAMES
+    end
+
     def __js_call__(method, args)
       case method
       when "addEventListener"
@@ -191,7 +203,7 @@ module Dommy
       end
     end
 
-    def __event_parent__
+    def __internal_event_parent__
       nil
     end
   end
@@ -232,11 +244,11 @@ module Dommy
       @immediate_propagation_stopped
     end
 
-    def __prepare_for_dispatch__(target)
+    def __internal_prepare_for_dispatch__(target)
       @target ||= target
     end
 
-    def __set_current_target__(target)
+    def __internal_set_current_target__(target)
       @current_target = target
     end
 
@@ -276,6 +288,12 @@ module Dommy
       nil
     end
 
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    JS_METHOD_NAMES = %w[preventDefault stopPropagation stopImmediatePropagation composedPath initEvent].freeze
+    def __js_method_names__
+      JS_METHOD_NAMES
+    end
+
     def __js_call__(method, args)
       case method
       when "preventDefault"
@@ -314,7 +332,7 @@ module Dommy
     # Per spec, `load` events do not propagate to the Window when
     # composed paths are computed (resource-finished signal stays at
     # the target).
-    def __record_path__(targets)
+    def __internal_record_path__(targets)
       @composed_path = if @type == "load"
         targets.reject { |t| t.is_a?(Window) }
       else
@@ -348,6 +366,8 @@ module Dommy
   end
 
   class CustomEvent < Event
+    attr_reader :detail
+
     def initialize(type, init = nil)
       super
       @detail = read_init(init, "detail")
@@ -443,6 +463,380 @@ module Dommy
     end
   end
 
+  # `InputEvent` — fired by `input` / `beforeinput`. Carries `data`
+  # (the inserted text, if any) and `inputType` (insertText,
+  # deleteContentBackward, etc.).
+  class InputEvent < Event
+    def initialize(type, init = nil)
+      super
+      @data = read_init(init, "data")
+      @input_type = (read_init(init, "inputType") || "").to_s
+      @is_composing = !!read_init(init, "isComposing")
+    end
+
+    def __js_get__(key)
+      case key
+      when "data"
+        @data
+      when "inputType"
+        @input_type
+      when "isComposing"
+        @is_composing
+      else
+        super
+      end
+    end
+  end
+
+  # `PointerEvent` — pointer (mouse / touch / pen) unified events.
+  # Inherits from MouseEvent for coords / modifier keys; adds
+  # pointerId, pointerType, pressure, width, height, etc.
+  class PointerEvent < MouseEvent
+    def initialize(type, init = nil)
+      super
+      @pointer_id = (read_init(init, "pointerId") || 0).to_i
+      @pointer_type = (read_init(init, "pointerType") || "mouse").to_s
+      @pressure = (read_init(init, "pressure") || 0).to_f
+      @tangential_pressure = (read_init(init, "tangentialPressure") || 0).to_f
+      @width = (read_init(init, "width") || 1).to_f
+      @height = (read_init(init, "height") || 1).to_f
+      @tilt_x = (read_init(init, "tiltX") || 0).to_i
+      @tilt_y = (read_init(init, "tiltY") || 0).to_i
+      @twist = (read_init(init, "twist") || 0).to_i
+      @is_primary = !!read_init(init, "isPrimary")
+    end
+
+    def __js_get__(key)
+      case key
+      when "pointerId"
+        @pointer_id
+      when "pointerType"
+        @pointer_type
+      when "pressure"
+        @pressure
+      when "tangentialPressure"
+        @tangential_pressure
+      when "width"
+        @width
+      when "height"
+        @height
+      when "tiltX"
+        @tilt_x
+      when "tiltY"
+        @tilt_y
+      when "twist"
+        @twist
+      when "isPrimary"
+        @is_primary
+      else
+        super
+      end
+    end
+  end
+
+  # `ProgressEvent` — fired during long-running operations (XHR,
+  # fetch upload/download progress). Carries `loaded` / `total` /
+  # `lengthComputable`.
+  class ProgressEvent < Event
+    def initialize(type, init = nil)
+      super
+      @loaded = (read_init(init, "loaded") || 0).to_i
+      @total = (read_init(init, "total") || 0).to_i
+      @length_computable = !!read_init(init, "lengthComputable")
+    end
+
+    def __js_get__(key)
+      case key
+      when "loaded"
+        @loaded
+      when "total"
+        @total
+      when "lengthComputable"
+        @length_computable
+      else
+        super
+      end
+    end
+  end
+
+  # `Touch` — a single touch point on a touch-capable surface.
+  # Constructed by tests; tied to a target element and coordinate set.
+  #
+  # Spec: https://w3c.github.io/touch-events/#touch-interface
+  class Touch
+    attr_reader(
+      :identifier,
+      :target,
+      :client_x,
+      :client_y,
+      :page_x,
+      :page_y,
+      :screen_x,
+      :screen_y,
+      :radius_x,
+      :radius_y,
+      :rotation_angle,
+      :force
+    )
+
+    def initialize(init = {})
+      @identifier = (init["identifier"] || init[:identifier] || 0).to_i
+      @target = init["target"] || init[:target]
+      @client_x = (init["clientX"] || init[:clientX] || 0).to_f
+      @client_y = (init["clientY"] || init[:clientY] || 0).to_f
+      @page_x = (init["pageX"] || init[:pageX] || @client_x).to_f
+      @page_y = (init["pageY"] || init[:pageY] || @client_y).to_f
+      @screen_x = (init["screenX"] || init[:screenX] || @client_x).to_f
+      @screen_y = (init["screenY"] || init[:screenY] || @client_y).to_f
+      @radius_x = (init["radiusX"] || init[:radiusX] || 0).to_f
+      @radius_y = (init["radiusY"] || init[:radiusY] || 0).to_f
+      @rotation_angle = (init["rotationAngle"] || init[:rotationAngle] || 0).to_f
+      @force = (init["force"] || init[:force] || 0).to_f
+    end
+
+    def __js_get__(key)
+      case key
+      when "identifier"
+        @identifier
+      when "target"
+        @target
+      when "clientX"
+        @client_x
+      when "clientY"
+        @client_y
+      when "pageX"
+        @page_x
+      when "pageY"
+        @page_y
+      when "screenX"
+        @screen_x
+      when "screenY"
+        @screen_y
+      when "radiusX"
+        @radius_x
+      when "radiusY"
+        @radius_y
+      when "rotationAngle"
+        @rotation_angle
+      when "force"
+        @force
+      end
+    end
+  end
+
+  # `TouchList` — immutable, indexed collection of Touch points.
+  class TouchList
+    include Enumerable
+
+    def initialize(touches = [])
+      @touches = touches.to_a.freeze
+    end
+
+    def length
+      @touches.length
+    end
+
+    def item(index)
+      @touches[index.to_i]
+    end
+
+    def [](index)
+      item(index)
+    end
+
+    def each(&block)
+      @touches.each(&block)
+      self
+    end
+
+    def __js_get__(key)
+      case key
+      when "length"
+        length
+      else
+        item(key.to_i) if key.is_a?(Integer) || key.to_s.match?(/\A-?\d+\z/)
+      end
+    end
+
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    JS_METHOD_NAMES = %w[item].freeze
+    def __js_method_names__
+      JS_METHOD_NAMES
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "item"
+        item(args[0])
+      end
+    end
+  end
+
+  # `TouchEvent` — fires for touchstart / touchmove / touchend /
+  # touchcancel. Carries three TouchLists plus modifier keys.
+  #
+  # Spec: https://w3c.github.io/touch-events/#touchevent-interface
+  class TouchEvent < Event
+    def initialize(type, init = nil)
+      super
+      @touches = TouchList.new(Array(read_init(init, "touches") || []))
+      @target_touches = TouchList.new(Array(read_init(init, "targetTouches") || []))
+      @changed_touches = TouchList.new(Array(read_init(init, "changedTouches") || []))
+      @alt_key = !!read_init(init, "altKey")
+      @ctrl_key = !!read_init(init, "ctrlKey")
+      @shift_key = !!read_init(init, "shiftKey")
+      @meta_key = !!read_init(init, "metaKey")
+    end
+
+    attr_reader :touches, :target_touches, :changed_touches
+
+    def __js_get__(key)
+      case key
+      when "touches"
+        @touches
+      when "targetTouches"
+        @target_touches
+      when "changedTouches"
+        @changed_touches
+      when "altKey"
+        @alt_key
+      when "ctrlKey"
+        @ctrl_key
+      when "shiftKey"
+        @shift_key
+      when "metaKey"
+        @meta_key
+      else
+        super
+      end
+    end
+  end
+
+  # `ClipboardEvent` — fires for copy / cut / paste. Carries the
+  # `clipboardData` payload as a DataTransfer.
+  #
+  # Spec: https://w3c.github.io/clipboard-apis/#clipboard-event-interface
+  class ClipboardEvent < Event
+    def initialize(type, init = nil)
+      super
+      @clipboard_data = read_init(init, "clipboardData")
+    end
+
+    attr_reader :clipboard_data
+
+    def __js_get__(key)
+      case key
+      when "clipboardData"
+        @clipboard_data
+      else
+        super
+      end
+    end
+  end
+
+  # `CompositionEvent` — IME composition events (compositionstart /
+  # compositionupdate / compositionend). `data` holds the composing text.
+  class CompositionEvent < Event
+    def initialize(type, init = nil)
+      super
+      @data = (read_init(init, "data") || "").to_s
+    end
+
+    attr_reader :data
+
+    def __js_get__(key)
+      case key
+      when "data"
+        @data
+      else
+        super
+      end
+    end
+  end
+
+  # `WheelEvent` — wheel-scroll events. Inherits MouseEvent (coords +
+  # modifier keys) and adds delta values + a delta mode.
+  class WheelEvent < MouseEvent
+    DOM_DELTA_PIXEL = 0
+    DOM_DELTA_LINE = 1
+    DOM_DELTA_PAGE = 2
+
+    def initialize(type, init = nil)
+      super
+      @delta_x = (read_init(init, "deltaX") || 0).to_f
+      @delta_y = (read_init(init, "deltaY") || 0).to_f
+      @delta_z = (read_init(init, "deltaZ") || 0).to_f
+      @delta_mode = (read_init(init, "deltaMode") || 0).to_i
+    end
+
+    attr_reader :delta_x, :delta_y, :delta_z, :delta_mode
+
+    def __js_get__(key)
+      case key
+      when "deltaX"
+        @delta_x
+      when "deltaY"
+        @delta_y
+      when "deltaZ"
+        @delta_z
+      when "deltaMode"
+        @delta_mode
+      else
+        super
+      end
+    end
+  end
+
+  # `FocusEvent` — focus / blur / focusin / focusout. `relatedTarget`
+  # is the element gaining/losing focus on the other side.
+  class FocusEvent < Event
+    def initialize(type, init = nil)
+      super
+      @related_target = read_init(init, "relatedTarget")
+    end
+
+    attr_reader :related_target
+
+    def __js_get__(key)
+      case key
+      when "relatedTarget"
+        @related_target
+      else
+        super
+      end
+    end
+  end
+
+  # `BeforeUnloadEvent` — `beforeunload` event. Setting `return_value`
+  # to a non-empty string (or calling `preventDefault`) signals the
+  # browser to prompt the user before navigating away.
+  class BeforeUnloadEvent < Event
+    def initialize(type = "beforeunload", init = nil)
+      super
+      @return_value = (read_init(init, "returnValue") || "").to_s
+    end
+
+    attr_accessor :return_value
+
+    def __js_get__(key)
+      case key
+      when "returnValue"
+        @return_value
+      else
+        super
+      end
+    end
+
+    def __js_set__(key, value)
+      case key
+      when "returnValue"
+        @return_value = value.to_s
+      else
+        super
+      end
+    end
+  end
+
   # `AbortController` + `AbortSignal` subset. Signal fires an
   # "abort" event and flips `[:aborted]` to true when the controller's
   # `abort()` is called; otherwise it stays inert.
@@ -453,7 +847,7 @@ module Dommy
     # signal. Convenient for APIs that need an already-cancelled token.
     def self.abort(reason = nil)
       signal = new
-      signal.__mark_aborted__(reason)
+      signal.__internal_mark_aborted__(reason)
       signal
     end
 
@@ -466,9 +860,9 @@ module Dommy
       signal = new
       reason = DOMException::TimeoutError.new("operation timed out")
       if scheduler
-        scheduler.set_timeout(proc { signal.__mark_aborted__(reason) }, ms.to_i)
+        scheduler.set_timeout(proc { signal.__internal_mark_aborted__(reason) }, ms.to_i)
       else
-        signal.__schedule_thread_timeout__(ms.to_i, reason)
+        signal.__internal_schedule_thread_timeout__(ms.to_i, reason)
       end
 
       signal
@@ -483,12 +877,12 @@ module Dommy
       list = Array(signals).select { |s| s.is_a?(AbortSignal) }
       already = list.find(&:aborted?)
       if already
-        composite.__mark_aborted__(already.reason)
+        composite.__internal_mark_aborted__(already.reason)
         return composite
       end
 
       list.each do |sig|
-        sig.add_event_listener("abort", proc { composite.__mark_aborted__(sig.reason) })
+        sig.add_event_listener("abort", proc { composite.__internal_mark_aborted__(sig.reason) })
       end
 
       composite
@@ -501,11 +895,11 @@ module Dommy
 
     # Background-thread timeout used by `AbortSignal.timeout` when no
     # scheduler is provided. Kept package-private; tests can also
-    # drive the abort manually via `__mark_aborted__`.
-    def __schedule_thread_timeout__(ms, reason)
+    # drive the abort manually via `__internal_mark_aborted__`.
+    def __internal_schedule_thread_timeout__(ms, reason)
       Thread.new do
         sleep(ms.to_f / 1000.0)
-        __mark_aborted__(reason)
+        __internal_mark_aborted__(reason)
       end
 
       nil
@@ -542,6 +936,12 @@ module Dommy
       nil
     end
 
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    JS_METHOD_NAMES = %w[addEventListener removeEventListener dispatchEvent throwIfAborted].freeze
+    def __js_method_names__
+      JS_METHOD_NAMES
+    end
+
     def __js_call__(method, args)
       case method
       when "addEventListener"
@@ -555,7 +955,7 @@ module Dommy
       end
     end
 
-    def __mark_aborted__(reason = nil)
+    def __internal_mark_aborted__(reason = nil)
       return if @aborted
 
       @aborted = true
@@ -579,10 +979,16 @@ module Dommy
       nil
     end
 
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    JS_METHOD_NAMES = %w[abort].freeze
+    def __js_method_names__
+      JS_METHOD_NAMES
+    end
+
     def __js_call__(method, args)
       case method
       when "abort"
-        @signal.__mark_aborted__(args[0])
+        @signal.__internal_mark_aborted__(args[0])
       end
     end
   end