dommy 0.9.0 → 0.10.0

data/lib/dommy/event.rb

@@ -6,12 +6,12 @@ module Dommy
   # surface.
 
   module EventTarget
-    def add_event_listener(type, listener = nil, options = nil, &block)
+    def add_event_listener(type, listener = nil, options = nil, event_handler: false, &block)
       cb = listener || block
       return nil if type.nil? || cb.nil?
 
       list = listeners_for(type.to_s)
-      entry = Listener.new(cb, options)
+      entry = Listener.new(cb, options, event_handler)
       # Per spec, a listener is deduplicated by (type, callback, capture) — so
       # the same function may be registered once as a capture and once as a
       # bubble listener.
@@ -56,6 +56,29 @@ module Dommy
       nil
     end
 
+    # Event handler IDL attributes (`el.onclick = fn`, `window.onload = fn`): one
+    # named handler registered as a listener, where assignment replaces any
+    # previous handler and a nil value removes it. Shared by Element and Window.
+    def event_name_from_on(key)
+      key.to_s.sub(/\Aon/, "").downcase
+    end
+
+    def on_handler(event_name)
+      @on_handlers&.[](event_name)
+    end
+
+    def set_on_handler(event_name, value)
+      @on_handlers ||= {}
+      previous = @on_handlers[event_name]
+      remove_event_listener(event_name, previous) if previous
+      if value
+        add_event_listener(event_name, value, event_handler: true)
+        @on_handlers[event_name] = value
+      else
+        @on_handlers.delete(event_name)
+      end
+    end
+
     def dispatch_event(event)
       return true if event.nil?
 
@@ -130,11 +153,16 @@ module Dommy
           end
         end
 
-        if entry.passive?
-          event.__internal_run_passive__ { invoke_listener_isolated(entry.listener, event) }
-        else
-          invoke_listener_isolated(entry.listener, event)
-        end
+        result =
+          if entry.passive?
+            event.__internal_run_passive__ { invoke_listener_isolated(entry.listener, event, self) }
+          else
+            invoke_listener_isolated(entry.listener, event, self)
+          end
+        # Event handler processing algorithm: a handler registered via onX has its
+        # return value processed — onerror on a global cancels on `true`, every
+        # other handler cancels on `false` (`onsubmit="return false"`).
+        __internal_process_event_handler_return__(event, result) if entry.event_handler?
 
         break if event.immediate_propagation_stopped?
       end
@@ -142,6 +170,19 @@ module Dommy
       nil
     end
 
+    # WHATWG event handler processing algorithm, step "process return value":
+    # the special error handler (onerror on a Window) cancels the event when the
+    # handler returns true; onbeforeunload has its own returnValue handling
+    # (left alone); any other handler cancels when it returns exactly false
+    # (`return false` from onclick/onsubmit). A non-cancelable event ignores it.
+    def __internal_process_event_handler_return__(event, result)
+      if event.type == "error" && defined?(Dommy::Window) && is_a?(Dommy::Window)
+        event.__js_call__("preventDefault", []) if result == true
+      elsif event.type != "beforeunload" && result == false
+        event.__js_call__("preventDefault", [])
+      end
+    end
+
     # Run one listener, isolating a throw so it can't escape the dispatch.
     # WHATWG "inner invoke": if a listener's callback throws, the exception is
     # *reported* (to the global error handler) and event dispatch continues with
@@ -152,8 +193,8 @@ module Dommy
     # engine/Ruby-version-dependent — on some QuickJS/Ruby combinations a JS
     # listener's throw surfaces as a Ruby exception here — so guard the
     # host-initiated path too, mirroring MutationObserver#flush.
-    def invoke_listener_isolated(listener, event)
-      CallableInvoker.invoke_listener(listener, event)
+    def invoke_listener_isolated(listener, event, current_target = nil)
+      CallableInvoker.invoke_listener(listener, event, current_target)
     rescue StandardError => e
       __dommy_dump_event_failure__(event, listener, e) if ENV["DOMMY_EVENT_DEBUG"]
       nil
@@ -181,7 +222,12 @@ module Dommy
 
     private
 
-    Listener = Struct.new(:listener, :options) do
+    Listener = Struct.new(:listener, :options, :event_handler) do
+      # True when this listener was registered via an event handler IDL/content
+      # attribute (el.onclick = fn / onclick="…"): its return value is processed
+      # per the event handler processing algorithm (a false return cancels).
+      def event_handler? = event_handler ? true : false
+
       def once?
         case options
         when Hash
@@ -489,7 +535,9 @@ module Dommy
         @immediate_propagation_stopped = true
         nil
       when "composedPath"
-        @composed_path.dup
+        # composedPath() is the event path only while the event is being
+        # dispatched; once dispatch finishes (currentTarget is null) it is empty.
+        @dispatch_flag ? @composed_path.dup : []
       when "initEvent"
         # WebIDL: the `type` argument is mandatory.
         raise Bridge::TypeError, "initEvent requires a type argument" if args.empty?
@@ -584,6 +632,71 @@ module Dommy
     end
   end
 
+  # UIEvent — the base for user-interface events (MouseEvent, KeyboardEvent,
+  # CompositionEvent, …), adding `view` (the associated window) and `detail`.
+  # Carries the legacy `initUIEvent`, which — like initEvent — is a no-op while
+  # the event is being dispatched.
+  class UIEvent < Event
+    def initialize(type, init = nil)
+      super
+      @view = read_init(init, "view")
+      # WebIDL: `view` is `Window?`, so a present non-null value that isn't a
+      # Window is a TypeError during dictionary conversion.
+      unless @view.nil? || (defined?(Bridge::UNDEFINED) && @view.equal?(Bridge::UNDEFINED)) ||
+             @view.is_a?(Dommy::Window)
+        raise Bridge::TypeError, "'view' member must be a Window or null"
+      end
+      @view = nil if defined?(Bridge::UNDEFINED) && @view.equal?(Bridge::UNDEFINED)
+      @detail = (read_init(init, "detail") || 0).to_i
+    end
+
+    def __js_get__(key)
+      case key
+      when "view" then @view
+      when "detail" then @detail
+      else super
+      end
+    end
+
+    js_methods %w[initUIEvent]
+    def __js_call__(method, args)
+      case method
+      when "initUIEvent"
+        # Deprecated initUIEvent(type, bubbles=false, cancelable=false, view=null,
+        # detail=0). Mandatory type; a no-op while dispatching.
+        raise Bridge::TypeError, "initUIEvent requires a type argument" if args.empty?
+
+        unless @dispatch_flag
+          init_event(args[0], args[1], args[2])
+          @view = args[3]
+          @detail = (args[4] || 0).to_i
+        end
+        nil
+      else
+        super
+      end
+    end
+  end
+
+  # ToggleEvent — fired at a `<details>` (and other poppable elements) when it
+  # opens/closes, exposing the transition via `oldState` / `newState`
+  # ("open"/"closed"). A plain Event subclass.
+  class ToggleEvent < Event
+    def initialize(type, init = nil)
+      super
+      @old_state = read_init(init, "oldState").to_s
+      @new_state = read_init(init, "newState").to_s
+    end
+
+    def __js_get__(key)
+      case key
+      when "oldState" then @old_state
+      when "newState" then @new_state
+      else super
+      end
+    end
+  end
+
   # PopStateEvent — fired on history back/forward. Exposes the history entry's
   # serialized state via `event.state` (the spec property; framework routers like
   # Turbo read `event.state.turbo` to recognise their own navigations and restore
@@ -604,6 +717,47 @@ module Dommy
     end
   end
 
+  # HashChangeEvent — fired on the window when the URL fragment changes (a
+  # fragment-navigation link, `location.hash = ...`). Exposes the full document
+  # URL before and after the change as `oldURL` / `newURL` (spec USVStrings). A
+  # plain `Event` subclass, NOT a CustomEvent.
+  class HashChangeEvent < Event
+    attr_reader :old_url, :new_url
+
+    def initialize(type, init = nil)
+      super
+      @old_url = read_init(init, "oldURL").to_s
+      @new_url = read_init(init, "newURL").to_s
+    end
+
+    def __js_get__(key)
+      case key
+      when "oldURL" then @old_url
+      when "newURL" then @new_url
+      else super
+      end
+    end
+  end
+
+  # SubmitEvent — fired on a form at submission. Exposes the button/input that
+  # triggered submission via `submitter` (null for `form.requestSubmit()` with
+  # no argument or an implicit submission). Frameworks (Turbo) read
+  # `event.submitter` to locate the clicked control.
+  class SubmitEvent < Event
+    attr_reader :submitter
+
+    def initialize(type, init = nil)
+      super
+      @submitter = read_init(init, "submitter")
+    end
+
+    def __js_get__(key)
+      return @submitter if key == "submitter"
+
+      super
+    end
+  end
+
   # `ErrorEvent` — the event interface for an uncaught error (fired at
   # `window.onerror`). Error-reporting code constructs it directly
   # (`new ErrorEvent("error", { message, error, … })`); without the constructor
@@ -658,7 +812,7 @@ module Dommy
     end
   end
 
-  class MouseEvent < Event
+  class MouseEvent < UIEvent
     def initialize(type, init = nil)
       super
       @button = read_init(init, "button") || 0
@@ -666,6 +820,10 @@ module Dommy
       @shift_key = !!read_init(init, "shiftKey")
       @alt_key = !!read_init(init, "altKey")
       @meta_key = !!read_init(init, "metaKey")
+      @buttons = read_init(init, "buttons") || 0
+      @related_target = read_init(init, "relatedTarget")
+      @screen_x = read_init(init, "screenX") || 0
+      @screen_y = read_init(init, "screenY") || 0
       @client_x = read_init(init, "clientX") || 0
       @client_y = read_init(init, "clientY") || 0
     end
@@ -682,6 +840,14 @@ module Dommy
         @alt_key
       when "metaKey"
         @meta_key
+      when "buttons"
+        @buttons
+      when "relatedTarget"
+        @related_target
+      when "screenX"
+        @screen_x
+      when "screenY"
+        @screen_y
       when "clientX"
         @client_x
       when "clientY"
@@ -690,6 +856,35 @@ module Dommy
         super
       end
     end
+
+    js_methods %w[initMouseEvent]
+    def __js_call__(method, args)
+      case method
+      when "initMouseEvent"
+        # Legacy initMouseEvent(type, bubbles, cancelable, view, detail, screenX,
+        # screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey, button,
+        # relatedTarget). A no-op while dispatching.
+        raise Bridge::TypeError, "initMouseEvent requires a type argument" if args.empty?
+
+        unless @dispatch_flag
+          init_event(args[0], args[1], args[2])
+          @view = args[3]
+          @detail = (args[4] || 0).to_i
+          @screen_x = (args[5] || 0).to_i
+          @screen_y = (args[6] || 0).to_i
+          @client_x = (args[7] || 0).to_i
+          @client_y = (args[8] || 0).to_i
+          @ctrl_key = !!args[9]
+          @alt_key = !!args[10]
+          @shift_key = !!args[11]
+          @meta_key = !!args[12]
+          @button = (args[13] || 0).to_i
+        end
+        nil
+      else
+        super
+      end
+    end
   end
 
   # `DragEvent` — fired during drag-and-drop with a `dataTransfer`
@@ -713,20 +908,60 @@ module Dommy
     end
   end
 
-  class KeyboardEvent < Event
+  class KeyboardEvent < UIEvent
+    js_methods %w[getModifierState initKeyboardEvent]
+
+    # Legacy keyCode values for non-printable keys (UI Events "keyCode"
+    # informative mapping) — jQuery-era code still branches on these.
+    LEGACY_KEY_CODES = {
+      "Backspace" => 8, "Tab" => 9, "Enter" => 13, "Shift" => 16,
+      "Control" => 17, "Alt" => 18, "CapsLock" => 20, "Escape" => 27,
+      " " => 32, "PageUp" => 33, "PageDown" => 34, "End" => 35, "Home" => 36,
+      "ArrowLeft" => 37, "ArrowUp" => 38, "ArrowRight" => 39, "ArrowDown" => 40,
+      "Delete" => 46, "Meta" => 91,
+    }.freeze
+
     def initialize(type, init = nil)
       super
       @key = read_init(init, "key").to_s
+      @code = read_init(init, "code").to_s
       @ctrl_key = !!read_init(init, "ctrlKey")
       @shift_key = !!read_init(init, "shiftKey")
       @alt_key = !!read_init(init, "altKey")
       @meta_key = !!read_init(init, "metaKey")
+      @repeat = !!read_init(init, "repeat")
+      @location = (read_init(init, "location") || 0).to_i
+      @is_composing = !!read_init(init, "isComposing")
+      @key_code = read_init(init, "keyCode")
+      @char_code = read_init(init, "charCode")
+    end
+
+    # Legacy keyCode: explicit init wins; a printable keypress reports the
+    # character code (Chrome parity), a printable keydown/keyup the upcased
+    # character; named keys use the legacy table.
+    def key_code
+      return @key_code.to_i if @key_code
+
+      if printable_key?
+        type == "keypress" ? @key.ord : @key.upcase(:ascii).ord
+      else
+        LEGACY_KEY_CODES[@key] || 0
+      end
+    end
+
+    # Legacy charCode: nonzero only on a printable keypress.
+    def char_code
+      return @char_code.to_i if @char_code
+
+      type == "keypress" && printable_key? ? @key.ord : 0
     end
 
     def __js_get__(key)
       case key
       when "key"
         @key
+      when "code"
+        @code
       when "ctrlKey"
         @ctrl_key
       when "shiftKey"
@@ -735,10 +970,56 @@ module Dommy
         @alt_key
       when "metaKey"
         @meta_key
+      when "repeat"
+        @repeat
+      when "location"
+        @location
+      when "isComposing"
+        @is_composing
+      when "keyCode"
+        key_code
+      when "charCode"
+        char_code
+      when "which"
+        key_code.zero? ? char_code : key_code
+      else
+        super
+      end
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "getModifierState"
+        case (args || []).first.to_s
+        when "Shift" then @shift_key
+        when "Control" then @ctrl_key
+        when "Alt" then @alt_key
+        when "Meta" then @meta_key
+        else false
+        end
+      when "initKeyboardEvent"
+        # Legacy initKeyboardEvent(type, bubbles, cancelable, view, key, location,
+        # modifiersList, repeat, locale). A no-op while dispatching.
+        raise Bridge::TypeError, "initKeyboardEvent requires a type argument" if args.empty?
+
+        unless @dispatch_flag
+          init_event(args[0], args[1], args[2])
+          @view = args[3]
+          @key = args[4].to_s
+          @location = (args[5] || 0).to_i
+          @repeat = !!args[7]
+        end
+        nil
       else
         super
       end
     end
+
+    private
+
+    def printable_key?
+      @key.length == 1
+    end
   end
 
   # `InputEvent` — fired by `input` / `beforeinput`. Carries `data`
@@ -1012,7 +1293,7 @@ module Dommy
 
   # `CompositionEvent` — IME composition events (compositionstart /
   # compositionupdate / compositionend). `data` holds the composing text.
-  class CompositionEvent < Event
+  class CompositionEvent < UIEvent
     def initialize(type, init = nil)
       super
       @data = (read_init(init, "data") || "").to_s
@@ -1065,7 +1346,7 @@ module Dommy
 
   # `FocusEvent` — focus / blur / focusin / focusout. `relatedTarget`
   # is the element gaining/losing focus on the other side.
-  class FocusEvent < Event
+  class FocusEvent < UIEvent
     def initialize(type, init = nil)
       super
       @related_target = read_init(init, "relatedTarget")