Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / css / invalidation / pseudo_class_invalidator.lucb

#==============================================================================================
#
#   pseudo_class_invalidator - style invalidation after a document-level pseudo-class state
#                              (:hover, :focus, :focus-within, :focus-visible, :target)
#                              moves from one node to another
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Invalidation/PseudoClassInvalidator.cpp (lines 1-107). Every element
#       under the invalidation root that is affected by the pseudo-class is matched against the
#       pseudo-class's rules with the old and the new state, and marked when the set of
#       matching rules differs.
#
#       Copyright (c) 2026-present, the Ladybird developers
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

## The captures of invalidate_style_after_pseudo_class_state_change_impl's lambdas: the state slot and the new
## state, the rules and the style computer.
struct CssInvalidationPseudoClassStateChange[T]:
    var pseudo_class: css_data.PseudoClass
    var state_slot: T*
    var new_state: T
    var rules: const CssRuleCache*
    var style_computer: CssStyleComputer*

## The captures of `matches_different_set_of_rules_after_state_change`'s for_each_matching_rules callback.
struct CssInvalidationMatchesDifferentRules[T]:
    var state_change: CssInvalidationPseudoClassStateChange[T]*
    var element: DomElement*
    var result: bool

## invalidate_style_after_pseudo_class_state_change_impl's `does_rule_match_on_element` lambda.
func css_invalidation_does_rule_match_on_element(style_computer: CssStyleComputer*, element: DomElement*, rule: const CssMatchingRule*) -> bool:
    let selector = rule.selector
    if css_selector_can_use_ancestor_filter(selector) and css_style_computer_should_reject_with_ancestor_filter(style_computer, selector):
        return false

    var context: SelectorEngineMatchContext
    var abstract_element: DomAbstractElement = ---
    let maybe_target_pseudo = css_selector_target_pseudo_element(selector)
    if maybe_target_pseudo == none:
        dom_abstract_element_construct(&abstract_element, element)
        return selector_engine_matches(selector, abstract_element, none, &context)
    let target_pseudo = maybe_target_pseudo else trap("unreachable")
    match css_selector_pseudo_element_selector_type(&target_pseudo):
        .before:
            dom_abstract_element_construct(&abstract_element, element, css_data.PseudoElement.before)
            return selector_engine_matches(selector, abstract_element, none, &context)
        .after:
            dom_abstract_element_construct(&abstract_element, element, css_data.PseudoElement.after)
            return selector_engine_matches(selector, abstract_element, none, &context)
        _:
            return false

## `matches_different_set_of_rules_after_state_change`'s for_each_matching_rules callback.
func css_invalidation_rules_match_differently[T](context: void*?, rules: const ak.Vector[CssMatchingRule]*) -> ak.IterationDecision:
    let captures = (CssInvalidationMatchesDifferentRules[T]*)(context else trap("no captures"))
    let state_change = captures.state_change
    for rule in &ak.vector_span_const(rules):
        let before = css_invalidation_does_rule_match_on_element(state_change.style_computer, captures.element, rule)
        # TemporaryChange change { state_slot, new_state };
        let saved_state = *state_change.state_slot
        *state_change.state_slot = state_change.new_state
        let after = css_invalidation_does_rule_match_on_element(state_change.style_computer, captures.element, rule)
        *state_change.state_slot = saved_state
        if before != after:
            captures.result = true
            return ak.IterationDecision.break_
    return ak.IterationDecision.continue_

## invalidate_style_after_pseudo_class_state_change_impl's `matches_different_set_of_rules_after_state_change` lambda.
func css_invalidation_matches_different_set_of_rules_after_state_change[T](state_change: CssInvalidationPseudoClassStateChange[T]*, element: DomElement*) -> bool:
    var captures = CssInvalidationMatchesDifferentRules[T](state_change = state_change, element = element, result = false)
    var abstract_element: DomAbstractElement = ---
    dom_abstract_element_construct(&abstract_element, element)
    let callback: func(void*?, const ak.Vector[CssMatchingRule]*) -> ak.IterationDecision = css_invalidation_rules_match_differently[T]
    css_rule_cache_for_each_matching_rules(state_change.rules, abstract_element, ak.Function1[const ak.Vector[CssMatchingRule]*, ak.IterationDecision](call = callback, context = &captures))
    return captures.result

## invalidate_style_after_pseudo_class_state_change_impl's `invalidate_affected_elements_recursively` lambda.
func css_invalidation_invalidate_affected_elements_recursively[T](state_change: CssInvalidationPseudoClassStateChange[T]*, node: DomNode*):
    if let element = as_if_dom_element(node):
        css_style_computer_push_ancestor(state_change.style_computer, element)
        if dom_element_affected_by_pseudo_class(element, state_change.pseudo_class) and css_invalidation_matches_different_set_of_rules_after_state_change(state_change, element):
            dom_node_set_needs_style_update(element.dom_node(), true)

    for child in dom_node_children(node):
        css_invalidation_invalidate_affected_elements_recursively(state_change, child)

    if let element = as_if_dom_element(node):
        css_style_computer_pop_ancestor(state_change.style_computer, element)

## Ported from Libraries/LibWeb/CSS/Invalidation/PseudoClassInvalidator.cpp:20 Web::CSS::Invalidation::invalidate_style_after_pseudo_class_state_change_impl.
func css_invalidation_invalidate_style_after_pseudo_class_state_change_impl[T](pseudo_class: css_data.PseudoClass, document: DomDocument*, state_slot: T*, invalidation_root: DomNode*, new_state: T):
    let root = tree_node_root(invalidation_root)
    let shadow_root = as_if_dom_shadow_root(root)
    var style_scope = dom_document_style_scope(document)
    if let shadow_root_ = shadow_root:
        style_scope = dom_shadow_root_style_scope(shadow_root_)

    var state_change = CssInvalidationPseudoClassStateChange[T](pseudo_class = pseudo_class, state_slot = state_slot, new_state = new_state, rules = css_style_scope_get_pseudo_class_rule_cache(style_scope, pseudo_class), style_computer = dom_document_style_computer(document))

    # Seed the ancestor filter with ancestors above the starting node,
    # so that ancestor-dependent selectors can still be correctly rejected.
    var ancestor = tree_node_parent(invalidation_root)
    while let current = ancestor:
        if let element = as_if_dom_element(current):
            css_style_computer_push_ancestor(state_change.style_computer, element)
        ancestor = tree_node_parent(current)

    css_invalidation_invalidate_affected_elements_recursively(&state_change, invalidation_root)

    ancestor = tree_node_parent(invalidation_root)
    while let current = ancestor:
        if let element = as_if_dom_element(current):
            css_style_computer_pop_ancestor(state_change.style_computer, element)
        ancestor = tree_node_parent(current)

## Ported from Libraries/LibWeb/CSS/Invalidation/PseudoClassInvalidator.cpp:97 Web::CSS::Invalidation::invalidate_style_after_pseudo_class_state_change.
pub func css_invalidation_invalidate_style_after_pseudo_class_state_change_dom_node(pseudo_class: css_data.PseudoClass, document: DomDocument*, state_slot: (DomNode*?)*, invalidation_root: DomNode*, new_state: DomNode*?):
    css_invalidation_invalidate_style_after_pseudo_class_state_change_impl(pseudo_class, document, state_slot, invalidation_root, new_state)

## Ported from Libraries/LibWeb/CSS/Invalidation/PseudoClassInvalidator.cpp:102 Web::CSS::Invalidation::invalidate_style_after_pseudo_class_state_change.
pub func css_invalidation_invalidate_style_after_pseudo_class_state_change_dom_element(pseudo_class: css_data.PseudoClass, document: DomDocument*, state_slot: (DomElement*?)*, invalidation_root: DomNode*, new_state: DomElement*?):
    css_invalidation_invalidate_style_after_pseudo_class_state_change_impl(pseudo_class, document, state_slot, invalidation_root, new_state)