Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / dom / slot_registry.lucb

#==============================================================================================
#
#   slot_registry - DOM::SlotRegistry: a shadow root's slots in tree order
#
#   DESCRIPTION:
#       Port of LibWeb/DOM/SlotRegistry.cpp (lines 1-74) and the inline functions of
#       SlotRegistry.h. The slots are weak references kept in tree order, so the first slot
#       with a name is found without walking the shadow tree.
#
#       Donor quirk, kept: `m_slot_count -= m_slots.remove_all_matching(...)` subtracts the
#       bool that remove_all_matching answers (whether anything was removed), not the number
#       of slots removed.
#
#==============================================================================================

## SlotRegistry::add's first remove_all_matching predicate: `!s`.
func dom_slot_registry_slot_is_dead(context: void*?, s: const gc.Weak[HtmlSlotElement]*) -> bool:
    return gc.weak_ptr(s) == none

## The predicate `&slot == s.ptr()` (SlotRegistry::add's remove_first_matching).
func dom_slot_registry_slot_is(context: void*?, s: const gc.Weak[HtmlSlotElement]*) -> bool:
    let slot = (HtmlSlotElement*)(context else trap("no slot"))
    return gc.weak_ptr(s) == slot

## The predicate `!s || &slot == s.ptr()` (SlotRegistry::remove).
func dom_slot_registry_slot_is_dead_or(context: void*?, s: const gc.Weak[HtmlSlotElement]*) -> bool:
    let slot = (HtmlSlotElement*)(context else trap("no slot"))
    let pointer = gc.weak_ptr(s) else return true
    return pointer == slot

## Ported from SlotRegistry.cpp:12 Web::DOM::SlotRegistry::add.
pub func dom_slot_registry_add(this: DomSlotRegistry*, slot: HtmlSlotElement*):
    let is_dead = ak.Function1[const gc.Weak[HtmlSlotElement]*, bool](call = dom_slot_registry_slot_is_dead, context = none)
    this.m_slot_count = this.m_slot_count -% (usize)ak.vector_remove_all_matching(&this.m_slots, is_dead)

    let is_slot = ak.Function1[const gc.Weak[HtmlSlotElement]*, bool](call = dom_slot_registry_slot_is, context = slot)
    let slot_removed = ak.vector_remove_first_matching(&this.m_slots, is_slot)
    if slot_removed:
        this.m_slot_count = this.m_slot_count -% 1

    var append = ak.vector_is_empty(&this.m_slots)
    if not append:
        let last = gc.weak_ptr(ak.vector_last(&this.m_slots)) else trap("VERIFY: live last slot")
        append = tree_node_is_before(last.dom_node(), slot.dom_node())
    if not append:
        append = not dom_slot_registry_try_insert_in_tree_order(this, slot)
    if append:
        ak.vector_append_t(&this.m_slots, gc.make_weak[HtmlSlotElement](slot))
        this.m_slot_count += 1

## The captures of try_insert_in_tree_order's find_first_index_if predicate.
struct DomSlotRegistryTryInsertInTreeOrderIsFollowing:
    var following_slot: HtmlSlotElement*

## try_insert_in_tree_order's predicate: `s.ptr() == following_slot`.
func dom_slot_registry_try_insert_in_tree_order_is_following(context: void*?, s: const gc.Weak[HtmlSlotElement]*) -> bool:
    let captures = (DomSlotRegistryTryInsertInTreeOrderIsFollowing*)(context else trap("no captures"))
    return gc.weak_ptr(s) == captures.following_slot

## Ported from SlotRegistry.cpp:30 Web::DOM::SlotRegistry::try_insert_in_tree_order.
func dom_slot_registry_try_insert_in_tree_order(this: DomSlotRegistry*, slot: HtmlSlotElement*) -> bool:
    # Walk forward from the slot we're adding to find the next registered slot. If we find one, insert before it.
    let shadow_root = tree_node_root(slot.dom_node())
    var node = tree_node_next_in_pre_order_t(slot.dom_node(), shadow_root)
    while let current = node:
        node = tree_node_next_in_pre_order_t(current, shadow_root)
        let following_slot = as_if_html_slot_element(current) else continue

        var captures = DomSlotRegistryTryInsertInTreeOrderIsFollowing(following_slot = following_slot)
        let predicate = ak.Function1[const gc.Weak[HtmlSlotElement]*, bool](call = dom_slot_registry_try_insert_in_tree_order_is_following, context = &captures)
        if let index = ak.vector_find_first_index_if(&this.m_slots, predicate):
            ak.vector_insert(&this.m_slots, index, gc.make_weak[HtmlSlotElement](slot))
            this.m_slot_count += 1
            return true
    return false

## Ported from SlotRegistry.cpp:52 Web::DOM::SlotRegistry::remove.
pub func dom_slot_registry_remove(this: DomSlotRegistry*, slot: HtmlSlotElement*):
    let predicate = ak.Function1[const gc.Weak[HtmlSlotElement]*, bool](call = dom_slot_registry_slot_is_dead_or, context = slot)
    this.m_slot_count = this.m_slot_count -% (usize)ak.vector_remove_all_matching(&this.m_slots, predicate)

## Ported from SlotRegistry.cpp:59 Web::DOM::SlotRegistry::first_slot_with_name.
pub func dom_slot_registry_first_slot_with_name(this: const DomSlotRegistry*, name: ak.FlyString) -> HtmlSlotElement*?:
    for slot in ak.vector_span_const(&this.m_slots):
        if let pointer = gc.weak_ptr(&slot):
            let slot_name = dom_slot_slot_name(&pointer.slot)
            if ak.fly_string_eq_fly_string(&slot_name, &name):
                return pointer

    return none

## Ported from SlotRegistry.cpp:69 Web::DOM::SlotRegistry::is_empty.
pub func dom_slot_registry_is_empty(this: const DomSlotRegistry*) -> bool:
    return this.m_slot_count == 0

## Ported from SlotRegistry.h:24 Web::DOM::SlotRegistry::for_each_slot.
pub func dom_slot_registry_for_each_slot(this: DomSlotRegistry*, callback: ak.Function1[HtmlSlotElement*, unit]):
    if dom_slot_registry_is_empty(this):
        return

    let call = callback.call else trap("VERIFY: callback")
    for slot in ak.vector_span(&this.m_slots):
        if let pointer = gc.weak_ptr(&slot):
            call(callback.context, pointer)