Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / dom / event_target_1.lucb

#==============================================================================================
#
#   event_target_1 - DOM::EventTarget: construction, the event listener list, dispatchEvent()
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/DOM/EventTarget.cpp (lines 51-375) with the inline functions of
#       EventTarget.h (lines 1-103): the constructor every platform object that is an event
#       target (every DOM node) runs, initialize and visit_edges, flattening the listener
#       options, the default passive value, adding and removing event listeners,
#       dispatchEvent(), the window event handler sets, determining the target of an event
#       handler and the event handler IDL attribute getter. event_target_2 continues the file.
#
#       Copyright (c) 2020-2022, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2022, Luke Wilde <lukew@serenityos.org>
#       Copyright (c) 2024, Glenn Skrzypczak <glenn.skrzypczak@gmail.com>
#       Copyright (c) 2025, Felipe Muñoz Mazur <felipe.munoz.mazur@protonmail.com>
#       Copyright (c) 2025, Simon Farre <simon.farre.cx@gmail.com>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Construction ============================================================================

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:51 Web::DOM::EventTarget::EventTarget.
pub func dom_event_target_construct(this: DomEventTarget*, realm: Realm*, may_interfere_with_indexed_property_access: JsObjectMayInterfereWithIndexedPropertyAccess = JsObjectMayInterfereWithIndexedPropertyAccess.no):
    bind_platform_object_construct_realm(this.bind_platform_object(), realm, may_interfere_with_indexed_property_access)

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:59 Web::DOM::EventTarget::construct_impl.
## https://dom.spec.whatwg.org/#dom-eventtarget-eventtarget
pub func dom_event_target_construct_impl(realm: Realm*) -> DomEventTarget*!:
    # The new EventTarget() constructor steps are to do nothing.
    return realm_create_dom_event_target(realm, realm, JsObjectMayInterfereWithIndexedPropertyAccess.no)

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:65 Web::DOM::EventTarget::initialize (override).
pub func dom_event_target_initialize_impl(base: JsCell*, realm: Realm*):
    # FIXME: We can't do this for UniversalGlobalScopeMixin classes, as this will run when creating the initial global object.
    #        During this time, the ESO is not setup, so it will cause a nullptr dereference in host_defined_intrinsics.
    if not dom_event_target_is_universal_global_scope_mixin((DomEventTarget*)base):
        web_set_prototype_for_interface(base, realm, BindInterfaceName.event_target)

    # Base::initialize(realm): PlatformObject inherits JS::Object's, which is JS::Cell's.
    js_cell_initialize_impl(base, realm)

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:75 Web::DOM::EventTarget::visit_edges (override).
pub func dom_event_target_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (DomEventTarget*)base
    bind_platform_object_visit_edges_impl(base, visitor)

    if let data = this.m_data:
        gc.cell_visitor_visit_vector(visitor, &data.event_listener_list)
        gc.cell_visitor_visit_hash_map(visitor, &data.event_handler_map)

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:85 Web::DOM::EventTarget::event_listener_list:
## a copy of the list (Vector<GC::Root<DOMEventListener>>).
pub func dom_event_target_event_listener_list(this: DomEventTarget*) -> ak.Vector[DomEventListener*?]:
    var list: ak.Vector[DomEventListener*?]
    let data = this.m_data else return list
    for listener in ak.vector_span(&data.event_listener_list):
        ak.vector_append_t(&list, listener)
    return list

# mark: Virtual defaults (EventTarget.h) ========================================================

## Ported from Libraries/LibWeb/DOM/EventTarget.h:30 Web::DOM::EventTarget::is_focusable (virtual).
pub func dom_event_target_is_focusable_impl(this: DomEventTarget*) -> bool:
    return false

## Ported from Libraries/LibWeb/DOM/EventTarget.h:42 Web::DOM::EventTarget::get_parent (virtual).
pub func dom_event_target_get_parent_impl(this: DomEventTarget*, arg0: DomEvent*) -> DomEventTarget*?:
    return none

## Ported from Libraries/LibWeb/DOM/EventTarget.h:53 Web::DOM::EventTarget::legacy_pre_activation_behavior (virtual).
## NOTE: These only exist for checkbox and radio input elements.
pub func dom_event_target_legacy_pre_activation_behavior_impl(this: DomEventTarget*):
    return

## Ported from Libraries/LibWeb/DOM/EventTarget.h:54 Web::DOM::EventTarget::legacy_cancelled_activation_behavior (virtual).
pub func dom_event_target_legacy_cancelled_activation_behavior_impl(this: DomEventTarget*):
    return

## Ported from Libraries/LibWeb/DOM/EventTarget.h:55 Web::DOM::EventTarget::legacy_cancelled_activation_behavior_was_not_called (virtual).
pub func dom_event_target_legacy_cancelled_activation_behavior_was_not_called_impl(this: DomEventTarget*):
    return

## Ported from Libraries/LibWeb/DOM/EventTarget.h:63 Web::DOM::EventTarget::is_universal_global_scope_mixin (virtual).
pub func dom_event_target_is_universal_global_scope_mixin_impl(this: DomEventTarget*) -> bool:
    return false

## Ported from Libraries/LibWeb/DOM/EventTarget.h:75 Web::DOM::EventTarget::is_dom_event_target (virtual).
pub func dom_event_target_is_dom_event_target_impl(this: DomEventTarget*) -> bool:
    return true

# mark: Flattening options ======================================================================

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:96 Web::DOM::flatten_event_listener_options.
## https://dom.spec.whatwg.org/#concept-flatten-options
func dom_flatten_event_listener_options_dom_event_listener_options_or_(options: DomEventListenerOptionsOrBool) -> bool:
    match options:
        # 1. If options is a boolean, then return options.
        .bool_(value):
            return value
        # 2. Return options["capture"].
        .dom_event_listener_options(event_listener_options):
            return event_listener_options.capture

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:106 Web::DOM::flatten_event_listener_options.
func dom_flatten_event_listener_options_dom_add_event_listener_options(options: DomAddEventListenerOptionsOrBool) -> bool:
    match options:
        # 1. If options is a boolean, then return options.
        .bool_(value):
            return value
        # 2. Return options["capture"].
        .dom_add_event_listener_options(add_event_listener_options):
            return add_event_listener_options.event_listener_options.capture

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:124 Web::DOM::flatten_add_event_listener_options.
## https://dom.spec.whatwg.org/#event-flatten-more
func dom_flatten_add_event_listener_options(options: DomAddEventListenerOptionsOrBool) -> DomFlattenedAddEventListenerOptions:
    # 1. Let capture be the result of flattening options.
    let capture = dom_flatten_event_listener_options_dom_add_event_listener_options(options)

    # 2. Let once be false.
    var once = false

    # 3. Let passive and signal be null.
    var passive: bool? = none
    var signal: DomAbortSignal*? = none

    # 4. If options is a dictionary, then:
    match options:
        .dom_add_event_listener_options(add_event_listener_options):
            # 1. Set once to options["once"].
            once = add_event_listener_options.once

            # 2. If options["passive"] exists, then set passive to options["passive"].
            if add_event_listener_options.passive != none:
                passive = add_event_listener_options.passive

            # 3. If options["signal"] exists, then set signal to options["signal"].
            if add_event_listener_options.signal != none:
                signal = add_event_listener_options.signal
        .bool_(_):
            # A boolean has no dictionary members: once stays false.
            once = false

    # 5. Return capture, passive, once, and signal.
    return DomFlattenedAddEventListenerOptions(capture = capture, passive = passive, once = once, signal = signal)

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:157 Web::DOM::default_passive_value.
## https://dom.spec.whatwg.org/#default-passive-value
func dom_default_passive_value(type_: ak.FlyString, event_target: DomEventTarget*?) -> bool:
    # 1. Return true if all of the following are true:
    #    - type is one of "touchstart", "touchmove", "wheel", or "mousewheel".
    #    - eventTarget is a Window object, or is a node whose node document is eventTarget, or is a node whose node document’s document element is eventTarget,
    #      or is a node whose node document’s body element is eventTarget.
    if ak.fly_string_eq_string_view(&type_, ak.sv("touchstart")) or ak.fly_string_eq_string_view(&type_, ak.sv("touchmove")) or ak.fly_string_eq_string_view(&type_, ak.sv("wheel")) or ak.fly_string_eq_string_view(&type_, ak.sv("mousewheel")):
        if let target = event_target:
            if is_html_window(target):
                return true

            if let node = as_if_dom_node(target):
                let document = dom_node_document(node)
                if document.dom_event_target() == target:
                    return true
                if let document_element = dom_document_document_element(document):
                    if document_element.dom_event_target() == target:
                        return true
                if let body = dom_document_body(document):
                    if body.dom_event_target() == target:
                        return true

    # 2. Return false.
    return false

# mark: Adding and removing event listeners =====================================================

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:178 Web::DOM::EventTarget::add_event_listener.
## https://dom.spec.whatwg.org/#dom-eventtarget-addeventlistener
pub func dom_event_target_add_event_listener(this: DomEventTarget*, type_: ak.FlyString, callback: DomIdlEventListener*?, options: DomAddEventListenerOptionsOrBool):
    # 1. Let capture, passive, once, and signal be the result of flattening more options.
    let flattened_options = dom_flatten_add_event_listener_options(options)

    # 2. Add an event listener with this and an event listener whose type is type, callback is callback, capture is capture, passive is passive,
    #    once is once, and signal is signal.

    let event_listener = heap_allocate_dom_event_listener(gc.cell_heap(this.cell()))
    event_listener.type_ = type_
    event_listener.callback = callback
    event_listener.signal = flattened_options.signal
    event_listener.capture = flattened_options.capture
    event_listener.passive = flattened_options.passive
    event_listener.once = flattened_options.once
    dom_event_target_add_an_event_listener(this, event_listener)

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:196 Web::DOM::EventTarget::add_event_listener_without_options.
## NOTE: These are for internal use only. They operate as though addEventListener(type, callback) was called instead of addEventListener(type, callback, options).
pub func dom_event_target_add_event_listener_without_options(this: DomEventTarget*, type_: ak.FlyString, callback: DomIdlEventListener*):
    dom_event_target_add_event_listener(this, type_, callback, .dom_add_event_listener_options(DomAddEventListenerOptions()))

## The captures of the abort steps add_an_event_listener adds to a listener's signal.
## NOTE: `this` and `listener` are protected by AbortSignal using GC::HeapFunction.
struct DomEventTargetAddAnEventListenerAbortSteps:
    var this: DomEventTarget*
    var listener: DomEventListener*

    static func call(context: void*?):
        let captures = (DomEventTargetAddAnEventListenerAbortSteps*)(context else trap("add_an_event_listener: no captures"))
        # 1. Remove an event listener with eventTarget and listener.
        dom_event_target_remove_an_event_listener(captures.this, captures.listener)

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:202 Web::DOM::EventTarget::add_an_event_listener.
## https://dom.spec.whatwg.org/#add-an-event-listener
pub func dom_event_target_add_an_event_listener(this: DomEventTarget*, listener: DomEventListener*):
    # FIXME: 1. If eventTarget is a ServiceWorkerGlobalScope object, its service worker’s script resource’s has ever been evaluated flag is set,
    #           and listener’s type matches the type attribute value of any of the service worker events, then report a warning to the console
    #           that this might not give the expected results. [SERVICE-WORKERS]

    let event_listener_list = &dom_event_target_ensure_data(this).event_listener_list

    # 2. If listener’s signal is not null and is aborted, then return.
    if let signal = listener.signal:
        if dom_abort_signal_aborted(signal):
            return

    # 3. If listener’s callback is null, then return.
    let callback = listener.callback else return

    # 4. If listener’s passive is null, then set it to the default passive value given listener’s type and eventTarget.
    if listener.passive == none:
        listener.passive = dom_default_passive_value(listener.type_, this)

    # 5. If eventTarget’s event listener list does not contain an event listener whose type is listener’s type, callback is listener’s callback,
    #    and capture is listener’s capture, then append listener to eventTarget’s event listener list.
    var found = false
    for entry in ak.vector_span(event_listener_list):
        let entry_callback = entry.callback else trap("an event listener in the list without a callback")
        if ak.fly_string_eq_fly_string(&entry.type_, &listener.type_) and dom_idl_event_listener_callback(entry_callback).callback == dom_idl_event_listener_callback(callback).callback and entry.capture == listener.capture:
            found = true
            break
    if not found:
        ak.vector_append_t(event_listener_list, listener)

    # 6. If listener’s signal is not null, then add the following abort steps to it:
    if let signal = listener.signal:
        let abort_steps = new DomEventTargetAddAnEventListenerAbortSteps(this = this, listener = listener) else trap("out of memory")
        _ = dom_abort_signal_add_abort_algorithm(signal, ak.Function0[unit](call = DomEventTargetAddAnEventListenerAbortSteps.call, context = abort_steps))

## `callbacks_match` of EventTarget::remove_event_listener (EventTarget.cpp:253).
func dom_event_target_remove_event_listener_callbacks_match(entry: DomEventListener*, callback: DomIdlEventListener*?) -> bool:
    if entry.callback == none and callback == none:
        return true
    let entry_callback = entry.callback else return false
    let other_callback = callback else return false
    return dom_idl_event_listener_callback(entry_callback).callback == dom_idl_event_listener_callback(other_callback).callback

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:244 Web::DOM::EventTarget::remove_event_listener.
## https://dom.spec.whatwg.org/#dom-eventtarget-removeeventlistener
pub func dom_event_target_remove_event_listener(this: DomEventTarget*, type_: ak.FlyString, callback: DomIdlEventListener*?, options: DomEventListenerOptionsOrBool):
    let event_listener_list = &dom_event_target_ensure_data(this).event_listener_list

    # 1. Let capture be the result of flattening options.
    let capture = dom_flatten_event_listener_options_dom_event_listener_options_or_(options)

    # 2. If this’s event listener list contains an event listener whose type is type, callback is callback, and capture is capture,
    #    then remove an event listener with this and that event listener.
    var found: DomEventListener*? = none
    for entry in ak.vector_span(event_listener_list):
        if ak.fly_string_eq_fly_string(&entry.type_, &type_) and dom_event_target_remove_event_listener_callbacks_match(entry, callback) and entry.capture == capture:
            found = entry
            break
    if let entry = found:
        dom_event_target_remove_an_event_listener(this, entry)

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:269 Web::DOM::EventTarget::remove_event_listener_without_options.
pub func dom_event_target_remove_event_listener_without_options(this: DomEventTarget*, type_: ak.FlyString, callback: DomIdlEventListener*):
    dom_event_target_remove_event_listener(this, type_, callback, .dom_event_listener_options(DomEventListenerOptions()))

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:275 Web::DOM::EventTarget::remove_an_event_listener.
## https://dom.spec.whatwg.org/#remove-an-event-listener
pub func dom_event_target_remove_an_event_listener(this: DomEventTarget*, listener: DomEventListener*):
    # FIXME: 1. If eventTarget is a ServiceWorkerGlobalScope object and its service worker’s set of event types to handle contains type,
    #           then report a warning to the console that this might not give the expected results. [SERVICE-WORKERS]

    # 2. Set listener’s removed to true and remove listener from eventTarget’s event listener list.
    listener.removed = true
    let data = this.m_data else trap("VERIFY: EventTarget has no data")
    for (index, entry) in ak.vector_span(&data.event_listener_list).indexed():
        if entry == listener:
            ak.vector_remove(&data.event_listener_list, index)
            break

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:287 Web::DOM::EventTarget::dispatch_event_binding.
## https://dom.spec.whatwg.org/#dom-eventtarget-dispatchevent
pub func dom_event_target_dispatch_event_binding(this: DomEventTarget*, event: DomEvent*) -> bool!:
    # 1. If event’s dispatch flag is set, or if its initialized flag is not set, then throw an "InvalidStateError" DOMException.
    if dom_event_dispatched(event):
        return try idl_throw(.idl_dom_exception(idl_invalid_state_error_create(bind_platform_object_realm(this.bind_platform_object()), ak.utf16_string_from_str("The event is already being dispatched."))))

    if not dom_event_initialized(event):
        return try idl_throw(.idl_dom_exception(idl_invalid_state_error_create(bind_platform_object_realm(this.bind_platform_object()), ak.utf16_string_from_str("Cannot dispatch an uninitialized event."))))

    # 2. Initialize event’s isTrusted attribute to false.
    dom_event_set_is_trusted(event, false)

    # 3. Return the result of dispatching event to this.
    return dom_event_target_dispatch_event(this, event)

# mark: Event handlers: the target ==============================================================

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:304 Web::DOM::is_window_reflecting_body_element_event_handler.
## https://html.spec.whatwg.org/multipage/webappapis.html#window-reflecting-body-element-event-handler-set
pub func dom_is_window_reflecting_body_element_event_handler(name: ak.FlyString) -> bool:
    return ak.fly_string_eq_fly_string(&name, &html_event_names_blur) or ak.fly_string_eq_fly_string(&name, &html_event_names_error) or ak.fly_string_eq_fly_string(&name, &html_event_names_focus) or ak.fly_string_eq_fly_string(&name, &html_event_names_load) or ak.fly_string_eq_fly_string(&name, &ui_events_event_names_resize) or ak.fly_string_eq_string_view(&name, ak.sv("scroll"))

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:316 Web::DOM::is_window_event_handler.
## https://html.spec.whatwg.org/multipage/webappapis.html#windoweventhandlers
func dom_is_window_event_handler(name: ak.FlyString) -> bool:
    let names = [&html_event_names_afterprint, &html_event_names_beforeprint, &html_event_names_beforeunload, &html_event_names_hashchange, &html_event_names_languagechange, &html_event_names_message, &html_event_names_messageerror, &html_event_names_offline, &html_event_names_online, &html_event_names_pagehide, &html_event_names_pageshow, &html_event_names_popstate, &html_event_names_rejectionhandled, &html_event_names_storage, &html_event_names_unhandledrejection, &html_event_names_unload]
    for candidate in names:
        if ak.fly_string_eq_fly_string(&name, candidate):
            return true
    return false

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:338 Web::DOM::determine_target_of_event_handler.
## https://html.spec.whatwg.org/multipage/webappapis.html#determining-the-target-of-an-event-handler
func dom_determine_target_of_event_handler(event_target: DomEventTarget*, name: ak.FlyString) -> DomEventTarget*?:
    # To determine the target of an event handler, given an EventTarget object eventTarget on which the event handler is exposed,
    # and an event handler name name, the following steps are taken:

    # 1. If eventTarget is not a body element or a frameset element, then return eventTarget.
    if not is_html_body_element(event_target) and not is_html_frame_set_element(event_target):
        return event_target

    let event_target_element = (HtmlElement*)event_target

    # 2. If name is not the name of an attribute member of the WindowEventHandlers interface mixin and the Window-reflecting
    #    body element event handler set does not contain name, then return eventTarget.
    if not dom_is_window_event_handler(name) and not dom_is_window_reflecting_body_element_event_handler(name):
        return event_target

    # 3. If eventTarget's node document is not an active document, then return null.
    let document = dom_node_document(event_target_element.dom_node())
    if not dom_document_is_active(document):
        return none

    # 4. Return eventTarget's node document's relevant global object.
    return as_dom_event_target((gc.Cell*)html_relevant_global_object((JsObject*)document))

## Ported from Libraries/LibWeb/DOM/EventTarget.cpp:363 Web::DOM::EventTarget::event_handler_attribute.
## https://html.spec.whatwg.org/multipage/webappapis.html#event-handler-attributes:event-handler-idl-attributes-2
pub func dom_event_target_event_handler_attribute(this: DomEventTarget*, name: ak.FlyString) -> IdlCallbackType*?:
    # 1. Let eventTarget be the result of determining the target of an event handler given this object and name.
    # 2. If eventTarget is null, then return null.
    let target = dom_determine_target_of_event_handler(this, name) else return none

    # 3. Return the result of getting the current value of the event handler given eventTarget and name.
    return dom_event_target_get_current_value_of_event_handler(target, name)